diff --git a/.github/workflows/Release-Tag.yml b/.github/workflows/Release-Tag.yml
deleted file mode 100644
index 6278c32..0000000
--- a/.github/workflows/Release-Tag.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-name: Release Tag
-
-on:
- push:
- tags:
- - master
-jobs:
- build:
- runs-on: ubuntu-latest
- steps:
- - uses: actions/checkout@v2
- - name: Get Version
- run: echo "##[set-output name=version;]$(echo '${{ github.event.head_commit.message }}' | egrep -o '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}')"
- id: extract_version_name
- - name: Create Release
- uses: actions/create-release@v1
- env:
- GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- with:
- tag_name: ${{ steps.extract_version_name.outputs.version }}
- release_name: Release ${{ steps.extract_version_name.outputs.version }}
- body: |
- Release ${{ steps.extract_version_name.outputs.version }}
\ No newline at end of file
diff --git a/.github/workflows/pypi.yml b/.github/workflows/pypi.yml
index c0da476..0fd4d9e 100644
--- a/.github/workflows/pypi.yml
+++ b/.github/workflows/pypi.yml
@@ -1,38 +1,55 @@
-name: PyPI package
+name: Publish to PyPI
on:
push:
- paths:
- - "setup.py"
- - "pso/__init__.py"
+ tags:
+ - "v*"
permissions:
contents: read
- packages: write
jobs:
- build-linux:
+ test:
runs-on: ubuntu-22.04
strategy:
- max-parallel: 5
matrix:
- python-version: ["3.9"]
+ python-version: ["3.10", "3.11"]
steps:
- - uses: actions/checkout@v3
- - name: Set up Python
- uses: actions/setup-python@v3
+ - uses: actions/checkout@v4
+ - name: Install uv and Python ${{ matrix.python-version }}
+ uses: astral-sh/setup-uv@v9
with:
+ version: "0.12.7"
python-version: ${{ matrix.python-version }}
- - name: Install dependencies
- run: |
- python -m pip install --upgrade pip
- if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
- pip install setuptools wheel twine
- - name: Build and publish
- env:
- TWINE_USERNAME: __token__
- TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
- run: |
- python setup.py bdist_wheel sdist
- twine upload dist/*.whl dist/*.tar.gz
+ enable-cache: true
+ - name: Sync dependencies
+ run: uv sync --locked --group dev
+ - name: Run tests
+ run: uv run --no-sync pytest -q
+ - name: Build package
+ run: uv build
+ - name: Check package distribution
+ run: uv run --no-sync twine check dist/*
+
+ publish:
+ needs: test
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v4
+ - name: Install uv and Python 3.11
+ uses: astral-sh/setup-uv@v9
+ with:
+ version: "0.12.7"
+ python-version: "3.11"
+ enable-cache: true
+ - name: Sync dependencies
+ run: uv sync --locked --group dev
+ - name: Build package
+ run: uv build
+ - name: Check package distribution
+ run: uv run --no-sync twine check dist/*
+ - name: Publish package to PyPI
+ uses: pypa/gh-action-pypa-publish@release/v1
+ with:
+ password: ${{ secrets.PYPI_TOKEN }}
diff --git a/.github/workflows/python-package-conda.yml b/.github/workflows/python-package-conda.yml
deleted file mode 100644
index 4503d7a..0000000
--- a/.github/workflows/python-package-conda.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-name: Python Package using Conda
-
-on: [push]
-
-jobs:
- build-linux:
- runs-on: ubuntu-22.04
- strategy:
- max-parallel: 5
-
- steps:
- - uses: actions/checkout@v3
- - name: Set up Python 3.9
- uses: actions/setup-python@v3
- with:
- python-version: "3.9"
- - name: Add conda to system path
- run: |
- # $CONDA is an environment variable pointing to the root of the miniconda directory
- echo $CONDA/bin >> $GITHUB_PATH
- - name: Install dependencies
- run: |
- conda env create --file conda_env/environment.yaml --name pso
- conda activate pso
- python mnist.py
diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml
new file mode 100644
index 0000000..03ab01f
--- /dev/null
+++ b/.github/workflows/python-package.yml
@@ -0,0 +1,41 @@
+name: Python package test
+
+on:
+ push:
+ paths:
+ - "pso/**"
+ - "pyproject.toml"
+ - "uv.lock"
+ - ".python-version"
+ - "README.md"
+ - "tests/**"
+ - ".github/workflows/python-package.yml"
+ pull_request:
+ paths:
+ - "pso/**"
+ - "pyproject.toml"
+ - "uv.lock"
+ - ".python-version"
+ - "README.md"
+ - "tests/**"
+ - ".github/workflows/python-package.yml"
+
+jobs:
+ test:
+ runs-on: ubuntu-22.04
+ strategy:
+ matrix:
+ python-version: ["3.10", "3.11"]
+
+ steps:
+ - uses: actions/checkout@v4
+ - name: Install uv and Python ${{ matrix.python-version }}
+ uses: astral-sh/setup-uv@v9
+ with:
+ version: "0.12.7"
+ python-version: ${{ matrix.python-version }}
+ enable-cache: true
+ - name: Sync dependencies
+ run: uv sync --locked --group dev
+ - name: Run tests
+ run: uv run --no-sync pytest -q
diff --git a/.gitignore b/.gitignore
index 32f41fa..5007588 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,4 +26,12 @@ logs/
발표 자료/
.vscode/
-metacode/
\ No newline at end of file
+metacode/
+
+# uv / venv
+.venv/
+.uv/
+
+# Local research execution state and large downloaded datasets
+.omc/
+runs/
\ No newline at end of file
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..2c07333
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.11
diff --git a/README.md b/README.md
index 89c6793..14530ea 100644
--- a/README.md
+++ b/README.md
@@ -1,271 +1,944 @@
[](https://github.com/jung-geun/PSO/actions/workflows/pypi.yml)
[](https://pypi.org/project/pso2keras/)
-[](https://sonar.pieroot.xyz/dashboard?id=pieroot_pso_AY4yioUduAwlZ9Y7RLBU)
-[](https://sonar.pieroot.xyz/dashboard?id=pieroot_pso_AY4yioUduAwlZ9Y7RLBU)
-[](https://sonar.pieroot.xyz/dashboard?id=pieroot_pso_AY4yioUduAwlZ9Y7RLBU)
-# PSO
+# PSO (pso2keras)
-keras model on particle swarm optimization
+Particle Swarm Optimization for PyTorch models (Version 4.0.0).
-현재 모델을 python 3.9 버전, tensorflow 2.11 버전에서 테스트 되었습니다
+`pso2keras`는 PyTorch `nn.Module` 모델 최적화를 위한 5단계 플러그인 아키텍처 기반의 미분 무관(Derivative-Free) Particle Swarm Optimization (PSO) 라이브러리입니다. v4.0.0부터 최적화 프로세스가 독립적으로 선택 가능한 5가지 스테이지(`method`, `initialization`, `evaluation`, `convergence`, `refinement`)로 정밀 분리되었습니다.
-### 목차
+기본 PSO 알고리즘 탐색은 역전파(`loss.backward()`) 없이 순전파 적합도 평가로만 동작하며, 필요 시 옵션 후처리인 하이브리드 Adam 미세조정(`refinement="adam"`)을 결합할 수 있습니다. macOS Metal Performance Shaders (MPS) 디바이스 가속, 재현 가능한 시드 제어, 가중치 바운드(`particle_min`/`particle_max`), 속도 제한 및 반사 경계, 고정 서브셋 적합도 평가, 정체 파티클 재초기화, 다종 논문 고전 무브먼트 알고리즘과 함께 다차원 수렴 실험 환경을 제공합니다.
-> [PSO 알고리즘 구현 및 새로운 시도](#pso-알고리즘-구현-및-새로운-시도)
->
-> [초기 세팅 및 사용 방법](#초기-세팅-및-사용-방법)
->
-> [구조 및 작동 방식](#구조-및-작동-방식)
->
-> [PSO 알고리즘을 이용하여 풀이한 문제들의 정확도](#pso-알고리즘을-이용하여-풀이한-문제들의-정확도)
->
-> [참고 자료](#참고-자료)
+Tested on **Python 3.10 / 3.11** with **PyTorch >= 2.13**.
-# PSO 알고리즘 구현 및 새로운 시도
+---
-Particle Swarm Optimization on tensorflow package
+## 목차
-pso 알고리즘을 사용하여 새로운 학습 방법을 찾는중 입니다
-병렬처리로 사용하는 논문을 찾아보았지만 이보다 더 좋은 방법이 있을 것 같아서 찾아보고 있습니다 - [[1]](#참고-자료)
+- [설치 및 환경](#설치-및-환경)
+- [Metal MPS 가속 및 디바이스 선택](#metal-mps-가속-및-디바이스-선택)
+- [빠른 시작 (Quick Start)](#빠른-시작-quick-start)
+- [5단계 플러그인 아키텍처 (5-Stage Plugin Architecture)](#5단계-플러그인-아키텍처-5-stage-plugin-architecture)
+- [무브먼트/알고리즘 매트릭스 (Method Comparison Matrix)](#무브먼트알고리즘-매트릭스-method-comparison-matrix)
+- [기법 분류 및 방법론 명확화 (Method Categorization)](#기법-분류-및-방법론-명확화-method-categorization)
+- [미지원 논문 기법 및 확장 계획 (Unsupported Paper Methods)](#미지원-논문-기법-및-확장-계획-unsupported-paper-methods)
+- [API 레퍼런스](#api-레퍼런스)
+ - [Optimizer 생성자](#optimizer-생성자)
+ - [fit 메서드](#fit-메서드)
+ - [적응형 모멘트 PSO (Adaptive Moment PSO - 저장소 독자 실험)](#적응형-모멘트-pso-adaptive-moment-pso---저장소-독자-실험)
+ - [하이브리드 Adam 미세조정 (Hybrid Refinement)](#하이브리드-adam-미세조정-hybrid-refinement)
+ - [결과 조회 메서드](#결과-조회-메서드)
+- [비교 CLI 도구 (Method Comparison CLI)](#비교-cli-도구-method-comparison-cli)
+- [실전 튜닝 및 벤치마크 (Tuning & Benchmark Results)](#실전-튜닝-및-벤치마크-tuning--benchmark-results)
+ - [PSO v4 다중 시드 실증 보고서 (Multi-Seed Empirical Report)](#pso-v4-다중-시드-실증-보고서-multi-seed-empirical-report)
+ - [확장 튜닝 및 파티클 스케일링 (Extended Tuning & Particle Scaling)](#확장-튜닝-및-파티클-스케일링-extended-tuning--particle-scaling)
+ - [공식 MNIST Deep Accuracy 프로토콜 (Deep Accuracy Protocol 1.0.0)](#공식-mnist-deep-accuracy-프로토콜-deep-accuracy-protocol-100)
+ - [Heavy PSO 고정 부분공간 반복 연구 (Heavy PSO Autoresearch 1.0.0)](#heavy-pso-고정-부분공간-반복-연구-heavy-pso-autoresearch-100)
+ - [Heavy PSO 교차 분할 강건성 검증 (Heavy PSO Cross-Split 1.0.0)](#heavy-pso-교차-분할-강건성-검증-heavy-pso-cross-split-100)
+- [Post-Training Prediction-Space Ensemble 연구 (PSO v8)](#post-training-prediction-space-ensemble-연구-pso-v8)
+ - [역사적 단일 시드 레퍼런스 (Historical Seed 42 Reference)](#역사적-단일-시드-레퍼런스-historical-seed-42-reference)
+- [출력 아티팩트 구조](#출력-아티팩트-구조)
+- [프로젝트 구조](#프로젝트-구조)
+- [보안 관련 참고 사항](#보안-관련-참고-사항)
+- [참고 문헌 (Primary References & DOIs)](#참고-문헌-primary-references--dois)
-기본 pso 알고리즘의 속도를 구하는 수식은 다음과 같습니다
+---
-> $$V_{t+1} = W_t + c_1 * r_1 * (Pbest_t - x_t) + c_2 * r_2 * (Gbest_t - x_t)$$
-
-다음 위치를 업데이트하는 수식입니다
-
-> $$x_{t+1} = x_{t} + V_{t+1}$$
-
-다음과 같은 변수를 사용합니다
-
-> $Pbest_t : 각 파티클의 지역 최적해$ $Gbest_t : 전역 최적해$ $W_t : 가중치$ $c_1, c_2 : 파라미터$ $r_1, r_2 : 랜덤 값$ $x_t : 현재 위치$ $V_{(t+1)} : 다음 속도$
-
-pso 알고리즘을 이용하여 keras 모델을 학습하는 방법을 탐구하고 있습니다
-현재는 xor, iris, mnist 문제를 풀어보았으며, xor 문제와 iris 문제는 100%의 정확도를 보이고 있습니다
-mnist 문제는 63%의 정확도를 보이고 있습니다
-
-[xor](#1-xor-문제) [iris](#2-iris-문제) [mnist](#3-mnist-문제)
-
-# 초기 세팅 및 사용 방법
-
-자동으로 conda 환경을 설정하기 위해서는 다음 명령어를 사용합니다
+## 설치 및 환경
+### PyPI 설치 및 패키지 추가
+`uv` 프로젝트에서 사용 시:
```shell
-conda env create -f conda_env/environment.yaml
+uv add pso2keras
```
-현재 python 3.9 버전, tensorflow 2.11 버전에서 테스트 되었습니다
-
-직접 설치하여 사용할 경우 pso2keras 패키지를 pypi 에서 다운로드 받아서 사용하시기 바랍니다
-
+기존 `pip` 환경에서 사용 시:
```shell
pip install pso2keras
```
-위의 패키지를 사용하기 위해서는 tensorflow 와 tensorboard 가 설치되어 있어야 합니다
+예제 데이터셋(Torchvision, Pandas, UCI Machine Learning Repository 지원) 지원 기능과 함께 설치할 경우:
+```shell
+uv add "pso2keras[examples]"
+```
-python 패키지를 사용하기 위한 라이브러리는 아래 코드를 사용합니다
+### 개발 및 환경 관리 (uv 기반)
+
+`pso2keras`는 Python 프로젝트 및 의존성 관리를 위해 [`uv`](https://github.com/astral-sh/uv)를 사용합니다.
+
+```shell
+# Python 3.11 버전 설치 및 프로젝트 동기화
+uv python install 3.11
+uv sync --locked --group dev --extra examples
+
+# 오프라인 pytest 테스트 수트 실행
+uv run pytest -q
+
+# XOR 수렴 실험 실행
+uv run python test/xor.py
+
+# 다종 알고리즘 비교 CLI 실행
+uv run python test/compare_methods.py --dataset xor --methods original inertia constriction fips clpso bare_bones adaptive_moment local_best quantum --seeds 42 43 44
+```
+
+---
+
+## Metal MPS 가속 및 디바이스 선택
+
+`pso2keras`는 macOS Metal Performance Shaders (MPS) 및 NVIDIA CUDA, CPU 디바이스 연산을 모두 지원합니다.
```python
+import torch
+
+built = hasattr(torch.backends, "mps") and torch.backends.mps.is_built()
+avail = hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+print(f"MPS built: {built}, available: {avail}")
+```
+
+- **자동 선택 (`device=None`, 기본값)**: `mps` -> `cuda` -> `cpu` 순으로 사용 가능 여부를 진단하여 자동 할당합니다.
+- **명시적 지정 (`device="mps"`, `device="cuda"`, `device="cpu"`)**: 지원되지 않는 디바이스 요청 시 `RuntimeError`를 발생시키며, CPU로 암묵적 대체되지 않습니다.
+
+---
+
+## 빠른 시작 (Quick Start)
+
+PyTorch `nn.Module`과 `BCEWithLogitsLoss`를 사용한 XOR 문제 최적화 예제입니다:
+
+```python
+import torch
+import torch.nn as nn
from pso import Optimizer
-pso_model = Optimizer(...)
-pso_model.fit(...)
+# 1. 시드 설정 및 신경망 모델 정의
+torch.manual_seed(101)
+model = nn.Sequential(
+ nn.Linear(2, 4),
+ nn.Tanh(),
+ nn.Linear(4, 1),
+)
+loss_fn = nn.BCEWithLogitsLoss()
+
+# 2. Optimizer 생성 (v4.0.0 5-Stage Plugin API)
+pso = Optimizer(
+ model,
+ loss_fn,
+ task="binary",
+ method="original", # 1995 Kennedy & Eberhart 기본 PSO (c0=c1=2.0, w=1.0)
+ initialization="model_noise", # 모델 가중치 + 유니폼 노이즈 초기화
+ evaluation="full", # 전체 학습 데이터셋 평가
+ convergence="none", # 정체 재초기화 미사용
+ refinement="none", # 미분 기반 후처리 미사용 (100% 미분 무관)
+ n_particles=40,
+ particle_min=-5.0,
+ particle_max=5.0,
+ initial_position_noise=1.0,
+ seed=101,
+ device=None,
+)
+
+# 3. 데이터 텐서 준비
+x_train = torch.tensor([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]], dtype=torch.float32)
+y_train = torch.tensor([[0.0], [1.0], [1.0], [0.0]], dtype=torch.float32)
+
+# 4. PSO 학습 실행
+best_score = pso.fit(
+ x_train,
+ y_train,
+ epochs=100,
+ renewal="loss",
+ output_dir="./result/xor",
+ log_format="csv",
+ checkpoint_interval=25,
+ save_info=True,
+)
+
+# 5. 최적 결과 조회
+best_score = pso.get_best_score() # (loss, accuracy, mse)
+best_model = pso.get_best_model() # 최적 가중치가 반영된 eval() 모드 nn.Module
+state_dict = pso.get_best_state_dict() # CPU 복사본 OrderedDict state_dict
+print("Best score (loss, accuracy, mse):", best_score)
```
-
+> **미분 무관(Derivative-Free) 최적화 노트**:
+> 기본 PSO 알고리즘 탐색(`original`, `inertia`, `constriction`, `fips`, `clpso`, `bare_bones`, `adaptive_moment`, `local_best`, `quantum`)은 역전파(`loss.backward()`), 기울기(gradient) 계산, 또는 PyTorch Optimizer(`torch.optim`)를 전혀 사용하지 않고 `torch.inference_mode()`에서 순전파 적합도만 평가합니다. 단, 옵션 후처리인 하이브리드 Adam 미세조정 (`refinement="adam"` 및 `refinement_epochs > 0`)을 명시적으로 활성화할 때에만 전역 최적해($G_{best}$) 가중치에 대해 Adam 경사하강법을 수행합니다.
-# 구조 및 작동 방식
+---
-## 파일 구조
+## 5단계 플러그인 아키텍처 (5-Stage Plugin Architecture)
+
+v4.0.0부터 Optimizer의 모든 동작은 5가지 독립적인 단계(Stage) 플러그인으로 캡슐화되어 있습니다:
+
+```
++-----------------------------------------------------------------------------------+
+| Optimizer.fit() |
++-----------------------------------------------------------------------------------+
+ |
+ +--> 1. Initialization Stage ("model_noise" | "uniform")
+ | : 파티클 초기 위치 및 속도 벡터 생성
+ |
+ +--> 2. Evaluation Stage ("full" | "fixed_subset")
+ | : 세대별 적합도 평가 데이터 분할 및 고정 서브셋 관리
+ |
+ +--> 3. Movement Stage ("original" | "inertia" | "constriction" | "fips" | ...)
+ | : SwarmState 스냅샷 기반 속도 및 위치 이동 제안 (Engine Invariants 적용)
+ |
+ +--> 4. Convergence Stage ("none" | "particle_reset" | "early_stopping")
+ | : 정체 파티클 재초기화 판정 및 이탈 제어
+ |
+ +--> 5. Refinement Stage ("none" | "adam")
+ : PSO 탐색 완료 후 전역 최적해($G_{best}$) 가중치 대상 미세조정
+```
+
+1. **Movement Stage (`method`)**: 파티클의 제안 속도 및 위치 이동식을 결정합니다. (`original`, `inertia`, `constriction`, `fips`, `clpso`, `bare_bones`, `adaptive_moment`, `local_best`, `quantum`)
+2. **Initialization Stage (`initialization`)**: 파티클 초기 위치 및 속도 분포를 정의합니다. (`model_noise`, `uniform`)
+3. **Evaluation Stage (`evaluation`)**: 학습 데이터 평가 방식을 결정합니다. (`full`, `fixed_subset`)
+4. **Convergence Stage (`convergence`)**: 파티클 개선 정체 여부를 감지하고 재초기화 또는 조기 종료를 수행합니다. (`none`, `particle_reset`, `early_stopping`)
+5. **Refinement Stage (`refinement`)**: Swarm 탐색 종료 후 최적해 가중치 후처리 미세조정을 수행합니다. (`none`, `adam`)
+
+사용자는 문자열 식별자를 전달하여 커스텀 및 표준 알고리즘 조합을 구성하거나, `pso.plugins` 모듈의 기반 클래스 (`MovementPlugin`, `InitializationPlugin`, `EvaluationPlugin`, `ConvergencePlugin`, `RefinementPlugin`)를 상속받아 고유한 플러그인을 확장할 수 있습니다.
+
+---
+
+## 무브먼트/알고리즘 매트릭스 (Method Comparison Matrix)
+
+| 문자열 식별자 (`method`) | 분류 (Categorization) | 수식 및 핵심 알고리즘 델타 (Algorithm Delta) | 표준 기본값 (Canonical Defaults) | 비용 / 상태 (Cost & State) | 기울기 (Gradient) | 주요 DOI 및 논문 제목 | 제약사항 및 주요 특징 |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| `original` | 논문 기반 고전 PSO | $v_{t+1} = v_t + c_0 r_1 \odot (p_{best} - x_t) + c_1 r_2 \odot (g_{best} - x_t)$
$x_{t+1} = x_t + v_{t+1}$ | $c_0=2.0, c_1=2.0, w=1.0$
(관성 가중치 곱셈 없음) | $O(1)$ 상태
추가 메모리 없음 | 미분 무관 (No) | [10.1109/ICNN.1995.488968](https://doi.org/10.1109/ICNN.1995.488968)
*Particle Swarm Optimization* (1995) | 관성 감쇄가 없는 1995년 원본 수식. negative_swarm, mutation, velocity_limit_ratio 지원. |
+| `inertia` | 논문 기반 고전 PSO | $v_{t+1} = w_t v_t + c_0 r_1 \odot (p_{best} - x_t) + c_1 r_2 \odot (g_{best} - x_t)$
($w_t$: $w_{max}$에서 $w_{min}$으로 선형 감쇄) | $c_0=2.0, c_1=2.0$
$w_{max}=0.9, w_{min}=0.4$ | $O(1)$ 상태
추가 메모리 없음 | 미분 무관 (No) | [10.1109/ICEC.1998.699146](https://doi.org/10.1109/ICEC.1998.699146)
*A Modified Particle Swarm Optimizer* (1998) | 관성 가중치 감쇄를 적용하여 국소 탐색과 전역 탐색의 균형을 도모. negative_swarm, mutation 지원. |
+| `constriction` | 논문 기반 고전 PSO | $v_{t+1} = \chi \left[ v_t + c_0 r_1 \odot (p_{best} - x_t) + c_1 r_2 \odot (g_{best} - x_t) \right]$
$\chi = \frac{2}{\|2 - \phi - \sqrt{\phi^2 - 4\phi}\|}, \phi = c_0 + c_1 > 4$ | $c_0=2.05, c_1=2.05$
($\phi=4.1, \chi \approx 0.72984$) | $O(1)$ 상태
추가 메모리 없음 | 미분 무관 (No) | [10.1109/4235.985692](https://doi.org/10.1109/4235.985692)
*The Particle Swarm - Explosion, Stability, and Convergence* (2002) | 수렴 수치 안정성을 보장하는 수축 계수 $\chi$ 적용. $\phi = c_0 + c_1 > 4$ 조건 필수 검증. |
+| `fips` | 논문 기반 고전 PSO | $v_{t+1} = \chi \left[ v_t + \sum_{k \in \mathcal{N}_i} \frac{U(0, \phi)}{K} \odot (p_{k,best} - x_t) \right]$
(All-to-All 토폴로지: 모든 이웃의 pbest 참조) | $\phi=4.1, \chi \approx 0.72984$
$K=N$ (전체 이웃 수) | 파티클당 $N$개 pbest 합산 연산 오버헤드 | 미분 무관 (No) | [10.1109/TEVC.2004.826074](https://doi.org/10.1109/TEVC.2004.826074)
*The Fully Informed Particle Swarm: Simpler, Maybe Better* (2004) | 전역 gbest 대신 스웜 내 모든 파티클의 pbest 정보를 가중 평산 참조. `negative_swarm` 미지원. |
+| `clpso` | 논문 기반 고전 PSO | $v_{t+1,d} = w_t v_{t,d} + c r_{t,d} (p_{p_d(i),best,d} - x_{t,d})$
차원별 학습 확률 $P_{c,i}$ 및 토너먼트 선택으로 대표 샘플링 | $c=1.49445, w: 0.9 \to 0.4$
갱신 주기 $\text{gap}=7$ | 차원별 엑젬플러 할당 행렬 `[N, D]` 저장 | 미분 무관 (No) | [10.1109/TEVC.2005.857610](https://doi.org/10.1109/TEVC.2005.857610)
*Comprehensive Learning Particle Swarm Optimizer* (2006) | 각 차원마다 서로 다른 파티클의 pbest를 조합하여 다봉성(Multimodal) 탐색. `negative_swarm` 미지원. |
+| `bare_bones` | 논문 기반 고전 PSO | $x_{t+1,d} \sim \mathcal{N}\left(\frac{p_{best,d} + g_{best,d}}{2}, \|p_{best,d} - g_{best,d}\|\right)$
50% 확률로 $p_{best,d}$ 직접 유지, $v=0$ 고정 | 매개변수 없음
(Parameter-free) | 속도 벡터 계산 생략 ($O(1)$ 공간) | 미분 무관 (No) | [10.1109/SIS.2003.1202251](https://doi.org/10.1109/SIS.2003.1202251)
*Bare Bones Particle Swarms* (2003) | 속도 벡터와 제어 계수를 제거하고 가우시안 확률 분포로 직접 위치 생성. `negative_swarm`, `mutation_swarm`, `velocity_limit_ratio` 미지원. |
+| `local_best` | 논문 기반 고전 PSO | $v_{t+1}=w_t v_t+c_0r_1\odot(p_{best}-x_t)+c_1r_2\odot(l_{best}-x_t)$
$l_{best}$는 래핑 링 이웃의 최고 pbest | $c_0=c_1=1.49618$
$w:0.9\to0.4$, 반경 $1$ | 파티클별 링 이웃 비교; 추가 적합도 평가 없음 | 미분 무관 (No) | [10.1109/CEC.2002.1004493](https://doi.org/10.1109/CEC.2002.1004493)
*Population Structure and Particle Swarm Performance* (2002) | `method_options={"neighborhood_radius": k}`로 반경 설정. mutation 및 velocity limit 지원. |
+| `quantum` | 논문 기반 고전 PSO | $m_{best}=\frac{1}{N}\sum_i p_{i,best}$
$x_{t+1}=p\pm\beta_t|m_{best}-x_t|\ln(1/u)$ | $\beta:1.0\to0.5$ | 속도 대신 직접 위치 제안; 세대별 $m_{best}$ 텐서 1개 | 미분 무관 (No) | [10.1109/CEC.2004.1330875](https://doi.org/10.1109/CEC.2004.1330875)
*Particle Swarm Optimization with Particles Having Quantum Behavior* (2004) | `negative_swarm`, `mutation_swarm`, `velocity_limit_ratio` 미지원. |
+| `adaptive_moment` | 저장소 독자 실험 | $u_t$: 관성 제안 속도
$m_t, s_t$: 1차/2차 경로 모멘트 추적 및 편향 보정
$v_{final} = (1-\lambda) u_t + \lambda v_{adapt}$ | $\text{blend}=0.25, c_0=0.5, c_1=0.3$
$w_{max}=0.9, w_{min}=0.1$
$\beta_1=0.9, \beta_2=0.999, \text{step}=1.0$ | 파티클당 2개 추가 모멘트 텐서 ($m_t, s_t$) | 미분 무관 (No) | DOI 없음
*(Repository Experiment)* | 역전파 및 추가 적합도 평가 없이 인-플라이트 경로 모멘트를 혼합하는 독자 실험 수식 (기본 blend=0.25 활성화). |
+
+---
+
+## 기법 분류 및 방법론 명확화 (Method Categorization)
+
+`pso2keras` 라이브러리에 포함된 기법들은 명확히 다음과 같이 3가지 범주로 분류됩니다:
+
+### 1. 논문 기반 고전 PSO (Paper-Faithful Classical PSO Methods)
+원문 논문의 수학적 수식과 이동 메커니즘을 정확히 구현한 알고리즘입니다:
+- `original`: Kennedy & Eberhart (1995) 원본 1995 PSO
+- `inertia`: Shi & Eberhart (1998) 관성 가중치 감쇄 PSO
+- `constriction`: Clerc & Kennedy (2002) 수축 계수 PSO
+- `fips`: Mendes et al. (2004) Fully Informed Particle Swarm
+- `clpso`: Liang et al. (2006) Comprehensive Learning PSO
+- `bare_bones`: Kennedy (2003) Bare Bones 확률형 PSO
+- `local_best`: Kennedy & Mendes (2002) 링 이웃 토폴로지 local-best PSO
+- `quantum`: Sun, Feng & Xu (2004) Quantum-Behaved PSO
+
+### 2. 딥러닝 적응 기법 (Deep-Learning Adaptations)
+PyTorch 고차원 매개변수 공간 최적화를 위해 도입된 실용적 플러그인 기법입니다:
+- `model_noise` (Initialization): PyTorch `nn.Module` 표준 초기화 가중치에 유니폼 노이즈 스케일(`[-initial_position_noise, initial_position_noise]`)을 부가하여 스웜 파티클을 확장.
+- `fixed_subset` (Evaluation): 전체 데이터셋에서 시드 기반으로 무작위 추출한 고정 서브셋으로 매 세대 파티클을 평가함으로써 Cross-batch 배치 평가 노이즈를 차단하고 공정한 pbest/gbest 수렴 점수를 비교.
+- `adam` (Refinement): 하이브리드 PSO-BP (Backpropagation) 결합 연구(Zhang et al. 2007)에서 영감을 얻어, PSO 전역 최적 탐색 완료 후 전역 최적해($G_{best}$) 위치에서 PyTorch Adam 최적화기로 최종 경사하강 미세조정을 수행 (논문의 고전 SGD-BP 재현이 아닌 PyTorch 매개변수 공간 맞춤형 Adam 변형).
+
+### 3. 저장소 독자 실험 (Repository Experiment)
+- `adaptive_moment` (Movement): PSO 탐색 중 미분 역전파나 추가 적합도 순전파 평가 없이 제안 속도 벡터의 1차/2차 경로 모멘트(Path Moments)를 추적하여 혼합하는 독자적 실험 기법입니다 (선택 시 blend=0.25 기본 활성화, blend=0.0으로 비활성화 가능).
+
+---
+
+## 미지원 논문 기법 및 확장 계획 (Unsupported Paper Methods)
+
+다음 기법들은 구조적 특성상 현재 5단계 순차 플러그인 아키텍처에 직접 포함되지 않으며, 스텁(Stub) 형태의 더미 옵션으로 제공하는 대신 미지원 및 향후 확장 논문 기법으로 명확히 문서화합니다:
+
+1. **Zhan et al. APSO Elitist Learning Strategy (ELS)**:
+ - *이유*: 스웜 이동 단계 외에 별도의 가우시안 변이(Gaussian mutation) 전역 최적해 파티클 후보군 순전파 평가(Out-of-band candidate evaluation)를 요구하여 세대당 적합도 평가 횟수 계약을 위배함.
+2. **Cooperative Subspace PSO (van den Bergh & Engelbrecht 2004)**:
+ - *이유*: 전체 가중치 벡터를 1차원으로 평탄화하여 평가하는 기본 아키텍처와 달리, 차원 분할 서브스페이스별 컨텍스트 벡터 분할 순전파 연산이 필요함.
+3. **PSO-NAS / 하이퍼파라미터 탐색 (Neural Architecture Search)**:
+ - *이유*: 신경망 구조 탐색 및 외부 루프 생성 모듈로, 연속적인 flat weight-space 무브먼트 범주를 벗어남.
+4. **적합도 전환형 APSO-Adam (Jiang & Han 2017)**:
+ - *이유*: 적합도 문턱값(Fitness Threshold) 조건에 따라 PSO 탐색 중간에 Adam 미세조정을 교대로 전환하는 구조로, PSO 탐색 완료 후 1회 수행되는 현재 5단계 순차 Refinement 플러그인 구조와 충돌함.
+
+---
+
+## API 레퍼런스
+
+### Optimizer 생성자
+
+`from pso import Optimizer` 구문을 통해 임포트합니다.
+
+```python
+Optimizer(
+ model: nn.Module,
+ loss: nn.Module,
+ *,
+ task: Literal["binary", "multiclass", "regression"],
+ method: str | MovementPlugin = "original",
+ initialization: str | InitializationPlugin = "model_noise",
+ evaluation: str | EvaluationPlugin = "full",
+ convergence: str | ConvergencePlugin = "none",
+ refinement: str | RefinementPlugin = "none",
+ method_options: dict[str, Any] | None = None,
+ n_particles: int = 10,
+ c0: float | None = None,
+ c1: float | None = None,
+ w_min: float | None = None,
+ w_max: float | None = None,
+ negative_swarm: float = 0.0,
+ mutation_swarm: float = 0.0,
+ particle_min: float | None = None,
+ particle_max: float | None = None,
+ velocity_limit_ratio: float | None = None,
+ boundary_strategy: Literal["clip", "reflect"] = "clip",
+ initial_position_noise: float = 0.05,
+ seed: int | None = None,
+ device: str | torch.device | None = None,
+ fitness_size: int | None = None,
+ convergence_patience: int = 10,
+ convergence_min_delta: float = 0.0001,
+ convergence_monitor: Literal["loss", "acc", "mse"] = "loss",
+ refinement_epochs: int = 0,
+ refinement_lr: float = 0.001,
+ moment_blend: float | None = None,
+ moment_beta1: float | None = None,
+ moment_beta2: float | None = None,
+ moment_step_size: float | None = None,
+ moment_epsilon: float | None = None,
+)
+```
+
+| 파라미터 | 타입 | 기본값 | 설명 |
+| --- | --- | --- | --- |
+| `model` | `nn.Module` | **필수** | 최적화 대상 PyTorch 신경망 모델 |
+| `loss` | `nn.Module` | **필수** | PyTorch 손실 함수 인스턴스 (`nn.BCEWithLogitsLoss()`, `nn.CrossEntropyLoss()`, `nn.MSELoss()`) |
+| `task` | `str` | **필수** | 작업 유형 (`"binary"`, `"multiclass"`, `"regression"`) |
+| `method` | `str` \| `MovementPlugin` | `"original"` | 이동 수식 플러그인 (`"original"`, `"inertia"`, `"constriction"`, `"fips"`, `"clpso"`, `"bare_bones"`, `"adaptive_moment"`, `"local_best"`, `"quantum"`) |
+| `initialization` | `str` \| `InitializationPlugin` | `"model_noise"` | 파티클 초기화 플러그인 (`"model_noise"`, `"uniform"`) |
+| `evaluation` | `str` \| `EvaluationPlugin` | `"full"` | 적합도 평가 플러그인 (`"full"`, `"fixed_subset"`) |
+| `convergence` | `str` \| `ConvergencePlugin` | `"none"` | 수렴 제어 플러그인 (`"none"`, `"particle_reset"`, `"early_stopping"`) |
+| `refinement` | `str` \| `RefinementPlugin` | `"none"` | 후처리 미세조정 플러그인 (`"none"`, `"adam"`) |
+| `method_options` | `dict` \| `None` | `None` | 커스텀 무브먼트 플러그인 전용 하이퍼파라미터 딕셔너리 |
+| `n_particles` | `int` | `10` | 스웜 내 파티클 개수 (>= 1) |
+| `c0`, `c1` | `float` \| `None` | `None` | 인지/사회적 계수 (`None` 지정 시 선택한 `method` 논문 기본값 자동 할당. 예: `original` -> 2.0, `inertia` -> 2.0, `constriction` -> 2.05) |
+| `w_min`, `w_max` | `float` \| `None` | `None` | 관성 가중치 범위 (`None` 지정 시 선택한 `method` 논문 기본값 자동 할당. 예: `original` -> 1.0, `inertia` -> 0.4~0.9) |
+| `negative_swarm` | `float` | `0.0` | 역사회적 속도를 적용할 파티클 비율 [0.0, 1.0] |
+| `mutation_swarm` | `float` | `0.0` | 무작위 변이 속도를 적용할 파티클 비율 [0.0, 1.0] |
+| `particle_min`, `particle_max` | `float` \| `None` | `None` | 파티클 가중치 경계 최소/최대 한계값 |
+| `velocity_limit_ratio` | `float` \| `None` | `None` | 성분별 최대 속도 비율 (`(0.0, 1.0]`). `particle_min`, `particle_max` 지정 필요 |
+| `boundary_strategy` | `str` | `"clip"` | 경계 이탈 처리 전략 (`"clip"`, `"reflect"`) |
+| `initial_position_noise` | `float` | `0.05` | 파티클 초기 위치 노이즈 스케일 |
+| `seed` | `int` \| `None` | `None` | 난수 생성 시드 |
+| `device` | `str` \| `device` \| `None` | `None` | 연산 디바이스 (`None` 시 `mps` -> `cuda` -> `cpu` 자동 선택) |
+| `fitness_size` | `int` \| `None` | `None` | `evaluation="fixed_subset"` 선택 시 세대별 고정 샘플링 서브셋 크기 |
+| `convergence_patience` | `int` | `10` | `convergence="particle_reset"` 또는 `"early_stopping"` 시 대기 세대 수 |
+| `convergence_min_delta` | `float` | `0.0001` | 정체 판단 최소 개선 지표 기준값 |
+| `convergence_monitor` | `str` | `"loss"` | 정체 모니터링 지표 (`"loss"`, `"acc"`, `"mse"`) |
+| `refinement_epochs` | `int` | `0` | `refinement="adam"` 선택 시 후처리 미세조정 에포크 수 |
+| `refinement_lr` | `float` | `0.001` | `refinement="adam"` 선택 시 후처리 미세조정 학습률 |
+| `moment_blend` | `float` \| `None` | `None` | `method="adaptive_moment"` 모멘트 혼합 비율 (`None` 지정 시 `adaptive_moment` 기본값 `0.25` 할당) |
+| `moment_beta1` | `float` \| `None` | `None` | `adaptive_moment` 1차 모멘트 감쇄 계수 (`None` 지정 시 기본값 `0.9`) |
+| `moment_beta2` | `float` \| `None` | `None` | `adaptive_moment` 2차 모멘트 감쇄 계수 (`None` 지정 시 기본값 `0.999`) |
+| `moment_step_size` | `float` \| `None` | `None` | `adaptive_moment` 모멘트 스텝 스케일 (`None` 지정 시 기본값 `1.0`) |
+| `moment_epsilon` | `float` \| `None` | `None` | `adaptive_moment` 수치 안정성 상수 (`None` 지정 시 기본값 `1e-8`) |
+
+> **검증 예외 규약**:
+> - `fitness_size` 파라미터는 `evaluation="fixed_subset"` 선택 시에만 허용되며, `evaluation="full"`에서 사용 시 `ValueError`가 발생합니다.
+> - `refinement_epochs > 0` 설정은 `refinement="adam"` 선택 시에만 허용됩니다.
+> - `method="quantum"`은 직접 위치를 제안하므로 `negative_swarm`, `mutation_swarm`, `velocity_limit_ratio`와 함께 사용할 수 없습니다.
+
+> **파라미터 우선순위 (Execution Parameter Precedence)**:
+> `Optimizer` 생성 시 지정된 실행 파라미터(`fitness_size`, `refinement_epochs`, `refinement_lr` 등)는 생성자 기본값으로 보관되며, `fit()` 메서드 호출 시 직접 전달된 매개변수가 생성자 기본값을 우선하여 재정의(Override)한 후 해당 실행 컨텍스트에 최종 적용됩니다.
+---
+
+### fit 메서드
+
+```python
+def fit(
+ self,
+ x: torch.Tensor,
+ y: torch.Tensor,
+ *,
+ epochs: int = 10,
+ batch_size: int | None = None,
+ fitness_size: int | None = None,
+ renewal: Literal["acc", "loss", "mse"] = "acc",
+ refinement_epochs: int = 0,
+ refinement_lr: float = 0.001,
+ validation_data: tuple[torch.Tensor, torch.Tensor] | None = None,
+ validation_split: float | None = None,
+ output_dir: str | os.PathLike | None = None,
+ log_format: Literal["none", "csv", "tensorboard"] = "none",
+ checkpoint_interval: int | None = None,
+ save_info: bool = False,
+) -> tuple[float, float, float]:
+ ...
+```
+
+---
+
+### 적응형 모멘트 PSO (Adaptive Moment PSO - 저장소 독자 실험)
+
+`method="adaptive_moment"`는 스웜 제안 속도 벡터의 1차/2차 경로 모멘트(Path Moments)를 추적하여 속도를 적응 조정하는 미분 무관 저장소 독자 실험 기법입니다:
+
+$$m_t = \beta_1 m_{t-1} + (1 - \beta_1) u_t, \quad s_t = \beta_2 s_{t-1} + (1 - \beta_2) u_t^2$$
+$$\hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \quad \hat{s}_t = \frac{s_t}{1 - \beta_2^t}$$
+$$v_{adapt} = \text{step\_size} \times \sqrt{\text{mean}(\hat{s}_t)} \times \frac{\hat{m}_t}{\sqrt{\hat{s}_t} + \epsilon}$$
+$$v_{final} = (1 - \lambda) u_t + \lambda v_{adapt} \quad (\lambda = \text{moment\_blend})$$
+
+- `method="adaptive_moment"` 문자열 식별자를 지정하거나 `AdaptiveMomentMovement` 플러그인을 선택하면 `moment_blend` 기본값이 `0.25`로 결정되어 파티클별 1차/2차 경로 모멘트 텐서($m_t, s_t$)가 메모리에 할당 및 추적됩니다. 반면 비적응형(Nonadaptive) 기법들(`original`, `inertia`, `constriction`, `fips`, `clpso`, `bare_bones`, `local_best`, `quantum`)을 선택하거나 `moment_blend = 0.0`으로 명시적 설정할 경우 경로 모멘트 텐서를 전혀 할당하지 않아 메모리를 보존합니다.
+- 고차원 및 복잡한 목적함수 연산 시 다양성은 증대되나 검증 손실/캘리브레이션 악화가 발생할 수 있으므로 문제별 선택적 옵트인(Opt-in)이 요구됩니다.
+
+---
+
+### 하이브리드 Adam 미세조정 (Hybrid Refinement)
+
+`refinement="adam"` 및 `refinement_epochs > 0` 선택 시, PSO 탐색으로 도출된 전역 최적해($G_{best}$) 파라미터 위치를 초기점으로 지정하여 PyTorch Adam 최적화기(`torch.optim.Adam`)로 최종 경사하강 미세조정을 수행합니다:
+
+1. **동일 적합도 데이터 분할**: `evaluation="fixed_subset"`이 활성화된 경우, Adam 미세조정도 PSO 탐색 단계에서 샘플링되어 유지된 동일한 고정 서브셋(`fixed_subset`)을 사용하여 미세조정 및 손실 평가를 수행합니다.
+2. **`eval()` 모드 유지**: 미세조정 중에도 모델은 `eval()` 모드를 유지하여 드롭아웃 및 배치 정규화 계수 변동을 차단합니다.
+3. **가중치 바운드 클램핑**: 매 Adam step 직후 `particle_min`, `particle_max` 경계로 파라미터를 즉시 클램핑합니다.
+4. **엄격한 수용 조건**: Adam 미세조정 결과가 기존 $G_{best}$ 스코어를 엄격히 향상시킨 경우에만 최종 점수 및 가중치를 반영합니다.
+5. **학술 연구 대비 구현 명확화**: Zhang et al. (2007, DOI 10.1016/j.amc.2006.07.025)의 고전 하이브리드 PSO-BP 논문에서 영감을 얻었으나, 논문의 역전파(SGD-BP) 수식을 그대로 재현한 것이 아니라 PyTorch 텐서 및 매개변수 생태계에 맞추어 Adam 최적화기로 경사하강 미세조정을 수행합니다.
+---
+
+### 결과 및 평가 메서드
+
+- `evaluate(x: torch.Tensor, y: torch.Tensor, *, batch_size: int | None = None) -> tuple[float, float, float]`: 전역 최적해 가중치($G_{best}$)로 입력 데이터 `(x, y)`에 대한 `(loss, accuracy, mse)` 점수를 직접 평가하여 반환합니다. 옵티마이저 내부 상태를 변경하지 않고 파일 아티팩트를 생성하지 않아 독립적인 검증 평가 및 수렴 비교 시 안전하게 활용됩니다.
+- `get_best_model() -> nn.Module | None`: 최적 가중치가 반영된 새로운 `eval()` 모드 PyTorch `nn.Module` 인스턴스를 반환합니다.
+- `get_best_score() -> tuple[float, float, float] | None`: 전역 최적해의 `(loss, accuracy, mse)` 튜플을 반환합니다.
+- `get_best_state_dict() -> collections.OrderedDict[str, torch.Tensor] | None`: 전역 최적 가중치의 CPU 복사본 state dict를 반환합니다.
+
+---
+
+## 비교 CLI 도구 (Method Comparison CLI)
+
+다양한 무브먼트 알고리즘과 플러그인 조합의 성능을 단일 CLI 명령으로 비교 평가할 수 있는 도구를 제공합니다:
+
+```shell
+# XOR 데이터셋 대상 9개 무브먼트 알고리즘 3개 시드 비교 실행
+uv run python test/compare_methods.py \
+ --dataset xor \
+ --methods original inertia constriction fips clpso bare_bones adaptive_moment local_best quantum \
+ --seeds 42 43 44 \
+ --epochs 100 \
+ --particles 30 \
+ --json-path ./result/comparison_xor.json
+```
+
+주요 CLI 파라미터:
+- `--dataset`: `xor`, `iris`, `mnist` 선택
+- `--methods`: 비교할 무브먼트 알고리즘 목록 (`original`, `inertia`, `constriction`, `fips`, `clpso`, `bare_bones`, `adaptive_moment`, `local_best`, `quantum`)
+- `--initialization`: `model_noise`, `uniform`
+- `--evaluation`: `full`, `fixed_subset`
+- `--convergence`: `none`, `particle_reset`, `early_stopping`
+- `--refinement`: `none`, `adam`
+- `--seeds`: 평가에 사용할 정수 시드 목록
+- `--json-path`, `--output-json`, `--json`: 비교 결과 집계 JSON 파일 저장 경로 (동일한 인자의 별칭 지원)
+
+알고리즘 수렴 성능 비교 시 `Optimizer.evaluate()` 메서드를 통해 동일한 데이터 평가 규약으로 `(loss, accuracy, mse)` 점수를 계산하여 아티팩트로 저장합니다.
+
+---
+
+## 실전 튜닝 및 벤치마크 (Tuning & Benchmark Results)
+
+> **※ 성능 측정 조건 알림**:
+> 아래 측정 결과는 구버전 튜닝 프로필 및 Benchmark Protocol 2.0.0 다중 시드 실증 보고서로 구분됩니다. PSO는 모든 문제에 만능인 보편적 성능을 제공하지 않으며 데이터셋 특성에 따른 튜닝이 필수적입니다.
+
+### PSO v4 다중 시드 실증 보고서 (Multi-Seed Empirical Report)
+
+v4.0.0 5단계 플러그인 아키텍처 기반의 종합 실증 평가 결과입니다. 벤치마크 프로토콜 v2.0.0에 따라 총 225회의 독립 측정(메인 벤치마크 7기법 × 5워크로드 × 5시드 = 175회, MNIST Ablation 10프로필 × 5시드 = 50회)을 수행하였으며, 모든 실행이 100% 성공적으로 완료되었습니다.
+
+- **상세 벤치마크 보고서**: [`REPORT.md`](REPORT.md)
+- **원천 측정 아티팩트**:
+ - 원시 JSON 데이터: [`benchmark_results/pso_v4_benchmark.json`](benchmark_results/pso_v4_benchmark.json)
+ - 메인 벤치마크 CSV: [`benchmark_results/pso_v4_main_benchmark.csv`](benchmark_results/pso_v4_main_benchmark.csv)
+ - Ablation 벤치마크 CSV: [`benchmark_results/pso_v4_ablation_benchmark.csv`](benchmark_results/pso_v4_ablation_benchmark.csv)
+- **전체 재현 실행 명령**:
+ ```shell
+ uv run --locked --extra examples python test/benchmark_suite.py --device mps
+ ```
+
+#### 메인 벤치마크 평균 순위 매트릭스 ($n=5$)
+
+각 워크로드에서 5개 시드의 평균 지표로 1위부터 7위까지 순위를 정한 뒤, 그 순위를 5개 워크로드에 걸쳐 평균한 결과입니다.
+
+| 기법 (`method`) | 평균 정확도 순위 | 평균 손실 순위 | 비고 |
+| --- | --- | --- | --- |
+| `constriction` | **1.60** | **1.60** | 수축 계수 PSO (5개 워크로드 종합 최저 평균 순위) |
+| `inertia` | **1.60** | **1.80** | 관성 가중치 감쇄 PSO (정확도 순위 constriction과 공동 1위) |
+| `adaptive_moment` (AM) | **3.60** | **3.60** | 경로 모멘트 추적 (독자 미분 무관 실험 기법) |
+| `bare_bones` (bare) | **4.80** | **4.60** | Bare Bones 가우시안 확률 분포 PSO |
+| `original` | **5.00** | **5.40** | 1995 Kennedy & Eberhart 기본 PSO |
+| `fips` (FIPS) | **5.20** | **5.00** | Fully Informed Particle Swarm (전체 이웃 pbest 합산) |
+| `clpso` (CLPSO) | **6.20** | **6.00** | Comprehensive Learning PSO (차원별 엑젬플러 토너먼트) |
+
+#### 벤치마크 시각화 차트 및 Ablation 연구
+
+| 메인 벤치마크 순위 히트맵 | MNIST 10-Profile Ablation 비교 |
+| --- | --- |
+|  |  |
+| *그림 1: 5개 워크로드, 시드 5개($n=5$) 평균 성능 순위 히트맵* | *그림 2: MNIST PCA32 10개 프로필 Ablation 수렴 비교 ($n=5$)* |
+
+> **핵심 실증 관찰사항 (Grounded Findings)**:
+> 1. **고전 무브먼트 기법의 낮은 평균 순위**: 5개 워크로드 종합 평균 순위에서 `constriction`과 `inertia`가 평균 정확도 순위 **1.60**으로 공동 1위를 기록하였으며, 손실 측면에서는 `constriction` (**1.60**)이 `inertia` (**1.80**) 대비 약간 더 낮은 손실 수렴 경향을 보였습니다.
+> 2. **미분 무관 Ablation 최고 성과**: pure derivative-free 기법 중 MNIST Ablation 최고 검증 정확도는 `adaptive_moment_.10` (경로 모멘트 혼합비 $\lambda=0.10$)으로 **63.00% ± 1.83%**를 기록했습니다 (단, 검증 손실은 **1.243339**로 `inertia_tuned`의 **1.236600** 대비 약간 높음).
+> 3. **경사도 기반 Adam 하이브리드 미세조정 구별**: `tuned_adam_100_lr.01` 프로필은 검증 정확도 **85.58% ± 0.24%**로 전체 10개 프로필 중 최고 성과를 달성했으나, 이는 역전파 경사도(`loss.backward()`)를 활용하는 하이브리드 Adam 미세조정이 적용된 것으로 순수 미분 무관(Derivative-Free) PSO 탐색과 구별됩니다.
+> 4. **해석상 유의사항**: 위 순위 및 성과는 5개 특정 워크로드 및 고정 예산에서의 표본 평가 결과이며, 보편적 우위(Universal Best)나 통계적 유의성을 주장하지 않습니다.
+
+### 확장 튜닝 및 파티클 스케일링 (Extended Tuning & Particle Scaling)
+
+기존 Protocol 2.0.0 결과와 별도로 Tuning Protocol 1.0.0을 실행했습니다. MNIST 첫 3,000개 학습 샘플에서 2,400/600 stratified inner split을 만들고 inner-train에만 PCA32 whitening을 적합하여 32개 후보를 시드 51~53으로 선택했습니다. 이후 선택된 각 기법의 후보를 전체 3,000개 학습 데이터로 다시 적합하고, 탐색에 사용하지 않은 1,000개 테스트 샘플에서 시드 61~65로 확인했습니다. 모든 비교는 미분 무관, 파티클 30개, 80세대 조건입니다.
+
+| 기법 | 검증 선택 후보 | Held-out 테스트 정확도 | Held-out 테스트 손실 | Fit 시간 |
+| --- | --- | ---: | ---: | ---: |
+| `local_best` | `local_best_r4_constant` | **62.64% ± 2.94%** | **1.211368 ± 0.059575** | 2.512s ± 0.048s |
+| `inertia` | `inertia_asymmetric` | 62.30% ± 3.01% | 1.212971 ± 0.078548 | 2.570s ± 0.035s |
+| `adaptive_moment` | `am_b0.06_s0.5` | 61.06% ± 0.91% | 1.229627 ± 0.022179 | 2.943s ± 0.256s |
+| `constriction` | `constriction_c205_canonical` | 60.66% ± 2.30% | 1.246275 ± 0.044657 | 2.521s ± 0.045s |
+| `quantum` | `quantum_beta_0.4_0.9` | 48.58% ± 2.71% | 1.519246 ± 0.052511 | 2.403s ± 0.022s |
+
+따라서 이 동일 예산 확인에서는 `adaptive_moment`가 최상위가 아니며, `local_best`와 `inertia`가 더 높은 평균 정확도를 기록했습니다. 표본 수는 $n=5$이므로 통계적 유의성이나 보편적 우위를 주장하지 않습니다.
+
+선택된 `adaptive_moment` 후보를 시드 71~75에서 파티클 수별로 추가 측정한 결과입니다:
+
+| 비교 방식 | 파티클 | 세대 | Particle-epochs | 테스트 정확도 | 테스트 손실 | Fit 시간 |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| Fixed epochs | 30 | 80 | 2,400 | 62.12% ± 3.07% | 1.193469 ± 0.086618 | 2.685s ± 0.090s |
+| Fixed epochs | 60 | 80 | 4,800 | 65.94% ± 0.87% | 1.074629 ± 0.046106 | 5.586s ± 0.517s |
+| Fixed epochs | 90 | 80 | 7,200 | 70.32% ± 2.16% | 0.931880 ± 0.038073 | 8.627s ± 0.448s |
+| Fixed epochs | 120 | 80 | 9,600 | **72.34% ± 1.82%** | **0.902448 ± 0.058380** | 11.174s ± 0.718s |
+| Fixed particle-epochs | 60 | 40 | 2,400 | 50.74% ± 2.66% | 1.534634 ± 0.078628 | 2.786s ± 0.095s |
+| Fixed particle-epochs | 90 | 27 | 2,430 | 47.82% ± 6.31% | 1.610771 ± 0.098843 | 3.109s ± 0.203s |
+| Fixed particle-epochs | 120 | 20 | 2,400 | 41.06% ± 2.36% | 1.800035 ± 0.072261 | 3.029s ± 0.179s |
+
+80세대를 유지하면 120개 파티클이 30개 대비 **+10.22%p** 높았지만 particle-evaluations는 4배, fit 시간은 **4.16배**였습니다. 반대로 약 2,400 particle-epochs를 고정하면 파티클 증가로 세대가 줄어 정확도가 낮아졌습니다. 즉, 이 실험에서 파티클 증가는 총 탐색량을 함께 늘릴 때만 개선으로 이어졌습니다.
+
+| 검증 선택 및 확인 | Adaptive Moment 파티클 스케일링 |
+| --- | --- |
+|  |  |
+
+- **상세 분석**: [`REPORT.md`](REPORT.md)
+- **원천 데이터**: [`pso_v4_tuning.json`](benchmark_results/pso_v4_tuning.json), [`search.csv`](benchmark_results/pso_v4_tuning_search.csv), [`confirmation.csv`](benchmark_results/pso_v4_tuning_confirmation.csv), [`particle_scaling.csv`](benchmark_results/pso_v4_particle_scaling.csv)
+- **재현 수트 명령**:
+ ```shell
+ uv run --locked --extra examples python test/tuning_suite.py --device mps
+ ```
+- **120p×80e 파티클 스케일링 재현성 검증 (별도 exact-replay + fresh-seed 검증)**:
+ - **결과**: **PASS**. 시드 71~75 exact replay는 **72.34% ± 1.82%**로 baseline과 같았고, 시드별 최대 정확도 차이는 **0.00%p**였습니다. 같은 시드의 초기 모델 fingerprint도 모두 일치했습니다.
+ - **독립 시드 확인**: 시드 81~85는 **73.60% ± 1.66%**였습니다. Baseline 대비 **+1.26%p**로 사전 허용 범위 ±3%p 안이며, baseline 95% t-CI **[70.08%, 74.60%]**와 fresh-seed 95% t-CI **[71.54%, 75.66%]**가 중첩됐습니다.
+ - **사전 선언 검증 조건**: exact-replay 시드 71~75의 시드별 테스트 정확도 최대 절대 차이 $\le 0.005$ (0.5%p)와 초기 모델 fingerprint 일치, 독립 시드 81~85 집단의 평균 정확도 절대 차이 $\le 0.03$ (3%p) 및 95% t-신뢰구간 중첩.
+ - **재현 검증 스크립트**: [`test/reproduce_scaling.py`](test/reproduce_scaling.py)
+ - **출력 아티팩트**: [`pso_v4_120p80_replication.json`](benchmark_results/pso_v4_120p80_replication.json), [`pso_v4_120p80_replication.csv`](benchmark_results/pso_v4_120p80_replication.csv)
+ - **재현 검증 명령**:
+ ```shell
+ uv run --locked --extra examples python test/reproduce_scaling.py --device mps
+ ```
+
+이 검증은 동일 PCA32 데이터와 테스트셋에서의 수치 재현성 확인입니다. 새로운 데이터셋에 대한 외적 타당성 검증이나 추가 하이퍼파라미터 선택으로 해석하지 않습니다.
+
+#### 120p epoch 확장 수렴 확인
+
+동일한 `adaptive_moment` 후보와 시드 71~75를 120개 파티클로 **240세대까지 중단 없이 연속 실행**하고 20세대마다 global-best 체크포인트를 평가했습니다. Epoch 80 체크포인트는 기존 baseline과 시드별 최대 차이 **0.00%p**로 일치했습니다.
+
+| Epoch | Particle-epochs | Training Best Loss | Test Accuracy | Test Loss |
+| ---: | ---: | ---: | ---: | ---: |
+| 80 | 9,600 | 0.684245 ± 0.046414 | 72.34% ± 1.82% | 0.902448 ± 0.058380 |
+| 120 | 14,400 | 0.508942 ± 0.026551 | 78.56% ± 0.88% | 0.686080 ± 0.033467 |
+| 160 | 19,200 | 0.426009 ± 0.011667 | 81.58% ± 1.17% | 0.599888 ± 0.027074 |
+| 200 | 24,000 | 0.385320 ± 0.008996 | 82.58% ± 0.64% | 0.555652 ± 0.020276 |
+| 240 | 28,800 | **0.359582 ± 0.009652** | **83.52% ± 1.05%** | **0.515820 ± 0.018827** |
+
+Epoch 80→240에서 training best loss는 평균 **47.30%** 감소했고 테스트 정확도는 5개 시드 모두 개선되어 평균 **+11.18%p** 상승했습니다. 200→240에서도 loss가 **6.68%** 감소하고 정확도가 평균 **+0.94%p** 상승했으며, 마지막 training-best 갱신은 각 시드에서 epoch 239 또는 240에 관측됐습니다. 따라서 **epoch 80은 조기 수렴 지점이 아니며, epoch 240에서도 완전한 plateau는 확인되지 않았습니다.** 다만 세대 구간별 정확도 이득은 +6.22%p(80→120), +3.02%p(120→160), +1.00%p(160→200), +0.94%p(200→240)로 감소하여 한계효용은 줄고 있습니다.
+
+
+
+- **실행 명령**: `uv run --locked --extra examples python test/epoch_convergence.py --device mps`
+- **원천 데이터**: [`pso_v4_epoch_convergence.json`](benchmark_results/pso_v4_epoch_convergence.json), [`pso_v4_epoch_convergence.csv`](benchmark_results/pso_v4_epoch_convergence.csv)
+
+이 checkpoint 테스트 궤적은 동일 테스트셋을 반복 관찰한 진단 자료입니다. 실제 epoch 선택이나 자동 중단 기준에는 별도 validation split과 validation metric을 사용해야 합니다.
+
+#### 전체 MNIST 60,000/10,000 학습
+
+공식 MNIST **train 60,000개 전체**와 **test 10,000개 전체**를 사용해 별도 실행했습니다. PCA32 whitening은 train 60,000개에만 적합했고, `evaluation="full"`과 `fitness_size=None`으로 모든 파티클이 매 epoch마다 학습 60,000개 전체에서 평가됐습니다. 모델은 이전 실험과 같은 `Linear(32,10)`, 파티클 120개, 연속 240 epochs, 시드 71~75입니다.
+
+| Epoch | Training Best Loss | Full Test Accuracy | Full Test Loss | 2k-fitness study 대비 정확도 |
+| ---: | ---: | ---: | ---: | ---: |
+| 80 | 0.768448 ± 0.026961 | 77.67% ± 1.50% | 0.725023 ± 0.033552 | +5.33%p |
+| 120 | 0.589822 ± 0.014141 | 83.28% ± 0.83% | 0.551133 ± 0.018616 | +4.72%p |
+| 160 | 0.511683 ± 0.013526 | 85.56% ± 0.56% | 0.482441 ± 0.012016 | +3.98%p |
+| 200 | 0.465194 ± 0.010498 | 86.85% ± 0.32% | 0.438875 ± 0.008499 | +4.27%p |
+| 240 | **0.436664 ± 0.008101** | **87.70% ± 0.36%** | **0.412078 ± 0.006848** | **+4.18%p** |
+
+Epoch 80→240에서 테스트 정확도는 **77.67%→87.70%(+10.03%p)**, training best loss는 **43.18% 감소**했습니다. 200→240에서도 정확도가 **+0.85%p**, loss가 **6.13%** 개선됐고 5개 시드 모두 정확도가 상승했으며 마지막 training-best는 모두 epoch 240에서 갱신됐습니다. 따라서 전체 데이터 학습에서도 epoch 240 시점의 plateau는 확인되지 않았습니다.
+
+이 실행은 5개 시드 합계 **144,000 particle-epochs**와 **86.4억 particle-sample evaluations**를 포함합니다. 2,000개 fitness subset 연구보다 모든 공통 checkpoint에서 테스트 정확도가 높았지만, PCA 적합 데이터와 fitness objective 및 RNG 소비 경로가 함께 달라지므로 위 차이는 기술적 비교이며 단일요인 인과 효과가 아닙니다.
+
+
+
+- **실행 명령**: `uv run --locked --extra examples python test/full_mnist_study.py --device mps`
+- **원천 데이터**: [`pso_v4_full_mnist.json`](benchmark_results/pso_v4_full_mnist.json), [`pso_v4_full_mnist.csv`](benchmark_results/pso_v4_full_mnist.csv)
+
+이 결과는 전체 공식 split을 사용하지만 입력은 여전히 PCA32이고 모델은 선형 분류기입니다. 원본 784차원 PSO 또는 CNN 결과로 해석하지 않습니다. Checkpoint 테스트 궤적 역시 중단 epoch 선택이 아니라 사후 진단에만 사용합니다.
+
+#### 공식 MNIST Deep Accuracy 프로토콜 (Deep Accuracy Protocol 1.0.0)
+
+PCA 차원 축소 없이 공식 MNIST 데이터셋 전체(학습 60,000개, 테스트 10,000개) 원본 $1 \times 28 \times 28$ 입력을 대상으로 딥 신경망 아키텍처 및 최적화기 특성을 평가했습니다 (`Deep Accuracy Protocol 1.0.0`, $n=3$, seeds 101~103). 픽셀 정규화 mean(0.13066)과 std(0.308108)는 학습 60,000개에서만 산출하여 검증/테스트 데이터 누수를 차단했습니다.
+
+본 실험은 2가지 실험 트랙(Lane)으로 구성됩니다:
+1. **아키텍처 레인 (Architecture Lane)**: Adam 최적화기(10 epochs, batch 256, lr 0.001) 고정 조건에서 구조적 인덕티브 바이어스(Inductive Bias) 효과 측정.
+ - `raw_linear`: `Linear(784, 10)` (7,850 params)
+ - `raw_mlp`: `Linear(784, 128) - ReLU - Linear(128, 64) - ReLU - Linear(64, 10)` (109,386 params)
+ - `compact_cnn`: `Conv2d(1,8,3) - ReLU - MaxPool2d - Conv2d(8,16,3) - ReLU - MaxPool2d - Linear(784,10)` (9,098 params)
+2. **최적화기 레인 (Optimizer Lane)**: 동일 `compact_cnn` (9,098 params) 모델에서 최적화 방식 비교.
+ - `adam_only`: Adam 10 epochs
+ - `pso_only`: pure all-weight PSO 40 generations (30 particles, fixed 2,000 fitness subset, 선택된 `adaptive_moment` 후보 설정)
+ - `hybrid`: PSO 40 generations 탐색 후 Adam 10 epochs 미세조정 (PSO 탐색 연산이 추가된 비동등 계산량 하이브리드)
+
+##### 아키텍처 레인 성과 (Adam 10 Epochs, Mean ± Sample SD, $n=3$)
+
+| 아키텍처 (`arch`) | 파라미터 수 | 테스트 정확도 (Mean ± SD) | 테스트 손실 (Mean ± SD) | 98% 정확도 최초 도달 |
+| --- | ---: | ---: | ---: | --- |
+| `raw_linear` | 7,850 | 92.45% ± 0.10% | 0.268945 ± 0.002050 | 미도달 |
+| `raw_mlp` | 109,386 | 97.70% ± 0.08% | 0.078368 ± 0.002818 | 미도달 |
+| `compact_cnn` | 9,098 | **98.53% ± 0.16%** | **0.043809 ± 0.004907** | **5 Epoch 이내 전 시드 달성** |
+
+> **참고**: `compact_cnn` 아키텍처는 3개 시드 모두 5 epoch 이내에 테스트 정확도 98% 이상을 달성했습니다 (시드 101: 4 epoch, 시드 102: 3 epoch, 시드 103: 5 epoch).
+
+##### 최적화기 레인 성과 (Compact CNN 9,098 Params, Mean ± Sample SD, $n=3$)
+
+| 최적화 기법 (`optimizer`) | 탐색 구성 | 테스트 정확도 (Mean ± SD) | 테스트 손실 (Mean ± SD) | 비고 |
+| --- | --- | ---: | ---: | --- |
+| `adam_only` | Adam 10 epochs | **98.53% ± 0.16%** | **0.043809 ± 0.004907** | 역전파 경사하강법 |
+| `pso_only` | PSO 40 epochs (30p × 40e) | 36.76% ± 3.76% | 14.104417 ± 8.075411 | 수렴 실패 (미분 무관 전가중치 탐색) |
+| `hybrid` (PSO→Adam) | PSO 40e + Adam 10e | 97.30% ± 0.75% | 0.086542 ± 0.023969 | 추가 탐색 연산에도 pure Adam 대비 저조 |
+
+
+
+- **실행 명령**: `uv run --locked --extra examples python test/deep_accuracy_study.py --device mps`
+- **원천 데이터**: [`benchmark_results/pso_v4_deep_accuracy.json`](benchmark_results/pso_v4_deep_accuracy.json), [`benchmark_results/pso_v4_deep_accuracy.csv`](benchmark_results/pso_v4_deep_accuracy.csv)
+- **핵심 종합 및 해석 제한**:
+ 1. Adam 조건을 고정한 아키텍처 레인에서는 원본 이미지의 공간적 인덕티브 바이어스가 중요했습니다. `compact_cnn`은 파라미터가 MLP의 약 1/12인데도 정확도가 0.83%p 높았습니다.
+ 2. 이 프로토콜의 30p × 40e·fixed-2k 예산에서 9,098개 전가중치를 직접 탐색한 순수 PSO는 36.76% ± 3.76%에 그쳐 역전파를 대체하지 못했습니다. 더 큰 예산에서의 이론적 한계를 증명한 결과는 아닙니다.
+ 3. PSO 탐색 후 Adam을 적용한 `hybrid`도 97.30% ± 0.75%로, 추가 PSO 계산량을 사용하면서 동일 10-epoch pure Adam(98.53% ± 0.16%)보다 낮았습니다. 측정한 설정에서는 PSO 초기점이 이점을 제공하지 않았습니다.
+ 4. 본 결과는 $n=3$ 기술적(descriptive) 표본 평가이며 보편적 성능 주장으로 확장하지 않습니다.
+
+
+### Heavy PSO 고정 부분공간 반복 연구 (Heavy PSO Autoresearch 1.0.0)
+
+MNIST/FashionMNIST × CompactCNN/WideCNN 네 workload에서 공식 test split을 봉인하고, 12 particles × 80 epochs × fixed-10k 조건으로 signed-hash 부분공간의 validation 품질과 persistent swarm-state 절감을 반복 평가했습니다.
+
+- 유지한 development 정책은 workload별 고정 global projection과 latent ratio 0.5를 사용해 baseline core state의 **49.18~50.00%**만 유지했습니다.
+- Seeds 101~103에서는 평균 accuracy **+2.5333%p**, 상대 NLL **2.4968% 개선**으로 고정 evaluator의 모든 gate를 통과했습니다.
+- 정책을 다시 선택하지 않은 seeds 111~113 confirmation은 평균 accuracy **+2.6342%p**, 상대 NLL **2.4955% 개선**이었지만, MNIST Wide 개선이 **+1.8633%p**로 사전 기준 +2%p에 0.1367%p 미달했습니다. 따라서 독립 확인된 Pareto 승리로 주장하지 않습니다.
+- Tensor-local hash와 geometry multiplier 0.75/0.5는 기각했습니다. 두 seed 집합을 합친 6-seed 수치는 사후 기술 통계이며 gate 판정값이 아닙니다.
+
+
+
+- **실행기**: [`test/heavy_pso_autoresearch.py`](test/heavy_pso_autoresearch.py)
+- **고정 평가기**: [`test/evaluate_heavy_autoresearch.py`](test/evaluate_heavy_autoresearch.py)
+- **결과**: [`benchmark_results/pso_v6_heavy_autoresearch.json`](benchmark_results/pso_v6_heavy_autoresearch.json), [`benchmark_results/pso_v6_heavy_autoresearch.csv`](benchmark_results/pso_v6_heavy_autoresearch.csv)
+- **상세 반복 분석**: [`REPORT.md` §6.13](REPORT.md#613-고정-부분공간-pso의-품질상태-pareto-반복-연구-heavy-pso-autoresearch-100)
+- **※ 주의 (후속 검증 결과)**: 후속 교차 분할 평가([`Heavy PSO 교차 분할 강건성 검증 (Heavy PSO Cross-Split 1.0.0)`](#heavy-pso-교차-분할-강건성-검증-heavy-pso-cross-split-100))에서 동일 정책이 개발 분할 평가 게이트를 통과하지 못했습니다. 따라서 본 절의 단일 개발 분할 수치는 새 validation split에 대한 강건성 증거가 아닙니다.
+
+### Heavy PSO 교차 분할 강건성 검증 (Heavy PSO Cross-Split 1.0.0)
+
+2개 개발 분할(split 20260905, 20260906) 및 시드 101~103, 매칭 baseline 재실행 조건(12 particles × 80 epochs × fixed-10k)에서 고정 부분공간 PSO의 새 validation split 재현성을 평가했습니다 (`HEAVY-PSO-CROSS-SPLIT 1.0.0`).
+
+- **실험 설계 및 개념적 구분**:
+ - **결정 탐색 vs 개발 변형**: 총 8회 결정 탐색(Decision Iterations 1~8)을 수행하였으며, Iteration 3의 Replica 1/2를 포함하여 총 9개 개발 변형(Development Variants)을 평가했습니다.
+ - **개발 단계 vs 확인 단계**: 2개 무작위 개발 분할(20260905/20260906) 기반의 개발 평가를 먼저 수행하고, 개발 게이트를 모두 통과한 후보에 한해 확인 분할(20260907) 기반 확인 평가를 진행하도록 설계했습니다.
+ - **검증 분할 vs 공식 테스트**: 학습 50,000개 / 검증 10,000개 층화 분할(Search/Validation)을 사용했으며, 공식 테스트 스플릿(10,000개)은 0회 로드 및 0회 평가로 완전히 봉인 유지했습니다.
+ - **관측 최상위 vs 최종 보존**: 9개 개발 변형 중 관측 최상위 후보와 최종 보존 정책을 엄격히 구분했습니다.
+
+- **주요 결과 및 판정**:
+ - **동결 정책 (`fixed_global_hybrid_v3`, Iteration 1)**: 전체 평균 정확도 개선 **+0.1533%p**, NLL 감소 **0.5546%**에 그쳤으며, 최악 accuracy 회귀 **-7.1767%p**, 최악 NLL 회귀 **+14.5682%**, MNIST Wide accuracy **-0.3617%p** (NLL **2.4600%** 악화)로 게이트를 통과하지 못해 **FAIL** 판정되었습니다.
+ - **관측 최상위 후보 (Iteration 5, Largest-Tensor Hash)**: 8회 결정 탐색 중 가장 높은 스코어(**-185.610686**)를 기록했으나, overall accuracy 개선 **+0.4400%p**, NLL 감소 **3.9493%**, 최악 accuracy 회귀 **-3.0667%p**, MNIST Wide accuracy **-2.6633%p** (NLL **2.1874%** 악화)로 역시 게이트 미달하여 **FAIL** 판정되었습니다.
+ - **확인 단계 보류 및 최종 보존 실패**: 9개 개발 변형 모두 개발 게이트를 통과하지 못함에 따라, 확인 분할(20260907) 실행은 과학적 엄격성 규칙에 따라 **실행하지 않고 보류(withheld)**되었으며, 최종 보존 정책은 `retained_policy = null`로 확정되었습니다. 공식 테스트 데이터 역시 0회 평가로 미사용 봉인 상태를 유지했습니다.
+
+- **자원 사용량 및 실행 집계**:
+ - **총 실행 횟수 (Runs)**: 432회 (9개 변형 × 8개 개발 셀 × 6회 실행)
+ - **총 목적함수 쿼리 (Queries)**: 414,720회
+ - **총 샘플 평가 수 (Sample Evaluations)**: 4,147,200,000회 (41.472억)
+ - **합산 실행 시간 (Wall Time)**: 3,162.9717초 (~52.7분)
+ - **공식 테스트 데이터 로드 및 평가**: 0회
+
+
+
+- **재현 및 아티팩트 발행 명령**:
+ ```shell
+ # 1. 교차 분할 탐색 미션 실행 (개발 단계)
+ uv run --no-sync python test/heavy_pso_cross_split.py --phase development --device mps
+
+ # 2. 개별 변형 평가 실행 예시
+ uv run --no-sync python test/evaluate_heavy_cross_split.py --development .omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0001-development.json --output .omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0001-development.json
+
+ # 3. 공개 아티팩트 및 시각화 생성 명령
+ uv run --no-sync python test/publish_heavy_cross_split.py --source-dir .omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z --output-json benchmark_results/pso_v7_heavy_cross_split.json --output-csv benchmark_results/pso_v7_heavy_cross_split.csv --output-plot history_plt/pso_v7_heavy_cross_split.png
+ ```
+
+- **공개 아티팩트 및 분석 링크**:
+ - **공개 JSON**: [`benchmark_results/pso_v7_heavy_cross_split.json`](benchmark_results/pso_v7_heavy_cross_split.json)
+ - **공개 CSV**: [`benchmark_results/pso_v7_heavy_cross_split.csv`](benchmark_results/pso_v7_heavy_cross_split.csv)
+ - **공개 PNG 시각화**: [`history_plt/pso_v7_heavy_cross_split.png`](history_plt/pso_v7_heavy_cross_split.png)
+ - **실행기/평가기/발행기**: [`test/heavy_pso_cross_split.py`](test/heavy_pso_cross_split.py), [`test/evaluate_heavy_cross_split.py`](test/evaluate_heavy_cross_split.py), [`test/publish_heavy_cross_split.py`](test/publish_heavy_cross_split.py)
+ - **반복 결정 로그**: [`.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/decision-log.md`](.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/decision-log.md)
+ - **상세 보고서 구문**: [`REPORT.md` §6.14](REPORT.md#614-heavy-pso-교차-분할-강건성-검증-heavy-pso-cross-split-100)
+
+
+### Post-Training Prediction-Space Ensemble 연구 (PSO v8)
+
+이 연구는 일반적인 역전파 학습이 끝난 뒤, **서로 독립적으로 학습한 모델의 예측 확률을 결합**할 때 PSO가 유용한지와 그 비용을 측정했습니다. 모델 가중치를 섞는 model soup가 아닙니다.
+
+#### 구조 및 평가 범위
+
+- MNIST와 FashionMNIST 각각에서 9,098개 파라미터의 `CompactCNN`을 Adam으로 독립 학습한 5개 멤버(seed `201`~`205`)를 사용했습니다. 각 멤버는 10 epoch이며, 비교를 위해 동일한 seed `201`의 50-epoch 단일 모델도 유지했습니다.
+- 탐색/검증 분할은 `50,000/10,000`개, split seed `20260904`이며 공식 test split은 개발 gate 통과 뒤에만 한 번 로드·평가했습니다. test 이후 재튜닝·재실행은 없습니다.
+- 각 멤버의 검증 확률을 캐시해 `(5, 10,000, 10)` 텐서로 만들고, 학습 가능한 `raw_weights`에 `softmax`를 적용해 simplex 가중치 `w`를 얻습니다. 결합은 `p_ensemble = Σᵢ wᵢ pᵢ`이며 목적함수는 확률 공간의 NLL입니다. **멤버의 독립적인 신경망 가중치는 평균하지 않고, 예측 확률만 결합합니다.**
+
+#### 공식 test 결과 (one-shot confirmation)
+
+| 방법 | MNIST accuracy / NLL | FashionMNIST accuracy / NLL |
+| --- | ---: | ---: |
+| PSO 가중치 (`30 particles × 30 epochs`) | **98.83% / 0.036178** | **89.54% / 0.291700** |
+| 균등 앙상블 | 98.86% / 0.036184 | 89.65% / 0.293522 |
+| SLSQP 가중치 | 98.83% / 0.036179 | 89.54% / 0.291696 |
+| 균등 앙상블 + temperature scaling | 98.86% / **0.034129** | 89.65% / **0.291996** |
+| 동일 50-epoch 예산 단일 모델 | 98.60% / 0.062102 | 89.93% / 0.302348 |
+
+PSO와 SLSQP는 두 workload에서 사실상 같은 NLL을 냈습니다. PSO를 동일 50-epoch 단일 모델과 비교하면 두 workload 평균 test NLL이 **22.633% 감소**했지만, 평균 accuracy는 **-0.08%p**였습니다. 이는 이 측정 조건의 기술적 결과이지 보편적 우위 주장이 아닙니다.
+
+#### 비용과 권고
+
+5개 독립 모델 pool은 단일 모델 대비 **저장 공간과 멤버 추론 비용이 5배**입니다. 또한 cached-probability simplex NLL은 매끄러운 저차원 문제였습니다. SLSQP는 workload당 **23회 평가 / 약 0.010초**로 PSO가 도달한 NLL을 재현했지만, PSO는 Iteration 1에서 swarm seed 하나당 **900회 평가 / 약 1.7~2.0초**가 필요했습니다. Iteration 0과 1을 합친 전체 PSO 연구 비용은 **14,400 queries / 144,000,000 candidate-sample evaluations / 30.2907초**입니다. 최종 Iteration 1만 보면 research **5,400 queries / 54,000,000 candidate-sample evaluations / 11.1512초**, 선택된 production **3.7888초**, SLSQP **46회 / 0.0201초**였습니다. Iteration 1의 production 시간과 해당 iteration의 pool 학습 시간 비율은 유지하지만, 두 iteration 합산 비용을 한 iteration의 학습 비용으로 나누지는 않습니다.
+
+따라서 이 연구의 권고는 **예측 공간 앙상블 자체는 유효한 선택으로 검토하되, 이처럼 매끄러운 simplex NLL에는 먼저 균등+temperature scaling 또는 SLSQP를 사용**하는 것입니다. PSO는 동일 목적함수에 대한 연구 비교 대상으로는 남지만, 측정된 비용을 고려하면 기본 선택으로 권하지 않습니다. 관련 배경은 [Deep Ensembles](https://arxiv.org/abs/1612.01474), [Temperature Scaling](https://arxiv.org/abs/1706.04599), [Model Soups](https://arxiv.org/abs/2203.05482), [Git Re-Basin](https://arxiv.org/abs/2209.04836)을 참조하십시오. 여기서 Model Soups와 Git Re-Basin은 각각 가중치 결합/정렬 문제를 다루며, 본 실험의 **독립 모델 가중치 평균**을 의미하지 않습니다.
+
+#### 재현 스크립트 및 공개 아티팩트
+
+- 실행기: [`test/post_training_pso_ensemble.py`](test/post_training_pso_ensemble.py)
+- 독립 평가기: [`test/evaluate_post_training_ensemble.py`](test/evaluate_post_training_ensemble.py)
+- 결과 JSON: [`benchmark_results/pso_v8_post_training_ensemble.json`](benchmark_results/pso_v8_post_training_ensemble.json)
+- 결과 CSV: [`benchmark_results/pso_v8_post_training_ensemble.csv`](benchmark_results/pso_v8_post_training_ensemble.csv)
+- 평가 JSON: [`benchmark_results/pso_v8_post_training_ensemble_evaluation.json`](benchmark_results/pso_v8_post_training_ensemble_evaluation.json)
+- 시각화: [`history_plt/pso_v8_post_training_ensemble.png`](history_plt/pso_v8_post_training_ensemble.png)
+- 결정 로그: [`.omc/autoresearch/post-training-pso-ensemble/runs/20260904T093144Z/decision-log.md`](.omc/autoresearch/post-training-pso-ensemble/runs/20260904T093144Z/decision-log.md)
+
+### 역사적 단일 시드 레퍼런스 (Historical Seed 42 Reference)
+
+> **※ 참고**: 아래 기록은 초기 개발 단계에서 단일 시드(Seed 42) 환경으로 측정된 역사적(Historical) 레퍼런스 데이터입니다. 다중 시드($n=5$) 기반의 종합 실증 데이터 및 메타데이터는 상단 실증 보고서 및 [`REPORT.md`](REPORT.md)를 참조하십시오.
+
+- **튜닝 프로필 PSO 전용 (`refinement="none"`)**: 검증 정확도 `60.30%` / 검증 손실 `1.2354`
+- **튜닝 프로필 하이브리드 Adam 후처리 (`refinement="adam"`, 100 에포크 @ lr 0.01)**:
+ - 최종 검증 평가: 검증 정확도 `84.60%` / 검증 손실 `0.4848`
+ - 전체 fit 실행 시간: `3.10초` (Apple Silicon MPS)
+---
+
+## 출력 아티팩트 구조
+
+`fit()` 실행 시 `output_dir`을 지정하면 다음과 같이 버전 4.0.0 메타데이터 구조를 포함하는 파일 아티팩트가 생성됩니다:
```plain
-|-- /conda_env # conda 환경 설정 파일
-| |-- environment.yaml # conda 환경 설정 파일
-|-- /metacode # pso 기본 코드
-| |-- pso_bp.py # 오차역전파 함수를 최적화하는 PSO 알고리즘 구현 - 성능이 99% 이상으로 나오나 목적과 다름
-| |-- pso_meta.py # PSO 기본 알고리즘 구현
-| |-- pso_tf.py # tensorflow 모델을 이용가능한 PSO 알고리즘 구현
-|-- /pso # tensorflow 모델을 학습하기 위해 기본 pso 코드에서 수정 - (psokeras 코드 의 구조를 사용하여 만듬)
-| |-- __init__.py # pso 모듈을 사용하기 위한 초기화 파일
-| |-- optimizer.py # pso 알고리즘 이용을 위한 기본 코드
-| |-- particle.py # 각 파티클의 정보 및 위치를 저장하는 코드
-|-- xor.py # pso 를 이용한 xor 문제 풀이
-|-- iris.py # pso 를 이용한 iris 문제 풀이
-|-- iris_tf.py # tensorflow 를 이용한 iris 문제 풀이
-|-- mnist.py # pso 를 이용한 mnist 문제 풀이
-|-- mnist_tf.py # tensorflow 를 이용한 mnist 문제 풀이
-|-- plt.ipynb # pyplot 으로 학습 결과를 그래프로 표현
-|-- README.md # 현재 파일
-|-- requirements.txt # pypi 에서 다운로드 받을 패키지 목록
+output_dir/
+|-- best_model.pt # 최적 모델 state_dict 및 런 메타데이터
+|-- checkpoints/ # checkpoint_interval 설정 시 세대별 체크포인트
+| |-- epoch-25.pt
+|-- history.csv # log_format="csv" 설정 시 학습 로그
+|-- tensorboard/ # log_format="tensorboard" 이벤트 로그
+|-- run.json # save_info=True 설정 시 5단계 플러그인 런 정보
```
-pso 라이브러리는 tensorflow 모델을 학습하기 위해 기본 ./metacode/pso_meta.py 코드에서 수정하였습니다 [[2]](#참고-자료)
+### `run.json` 예시 (v4.0.0):
-pso 알고리즘을 이용하여 오차역전파 함수를 최적화 하는 방법을 찾는 중입니다
-
-## 알고리즘 작동 방식
-
-> 1. 파티클의 위치와 속도를 초기화 한다.
-> 2. 각 파티클의 점수를 계산한다.
-> 3. 각 파티클의 지역 최적해와 전역 최적해를 구한다.
-> 4. 각 파티클의 속도를 업데이트 한다.
-
-# PSO 알고리즘을 이용하여 풀이한 문제들의 정확도
-
-## 1. xor 문제
-
-```python
-loss = 'mean_squared_error'
-
-pso_xor = Optimizer(
- model,
- loss=loss,
- n_particles=50,
- c0=0.35,
- c1=0.8,
- w_min=0.6,
- w_max=1.2,
- negative_swarm=0.1,
- mutation_swarm=0.2,
- particle_min=-3,
- particle_max=3,
-)
-
-best_score = pso_xor.fit(
- x_test,
- y_test,
- epochs=200,
- save=True,
- save_path="./result/xor",
- renewal="acc",
- empirical_balance=False,
- Dispersion=False,
- check_point=25,
-)
+```json
+{
+ "version": "4.0.0",
+ "task": "binary",
+ "device": "mps",
+ "loss_function": "BCEWithLogitsLoss",
+ "config": {
+ "method": "original",
+ "initialization": "model_noise",
+ "evaluation": "full",
+ "convergence": "none",
+ "refinement": "none",
+ "plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "gradient_required": false,
+ "fidelity": "canonical",
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "gradient_required": false,
+ "fidelity": "canonical",
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "gradient_required": false,
+ "fidelity": "canonical",
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "gradient_required": false,
+ "fidelity": "canonical",
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "gradient_required": false,
+ "fidelity": "canonical",
+ "options": {}
+ }
+ },
+ "n_particles": 40,
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": null,
+ "w_max": null,
+ "negative_swarm": 0.0,
+ "mutation_swarm": 0.0,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "velocity_limit_ratio": null,
+ "boundary_strategy": "clip",
+ "initial_position_noise": 1.0,
+ "seed": 101,
+ "fitness_size": null,
+ "convergence_patience": 10,
+ "convergence_min_delta": 0.0001,
+ "convergence_monitor": "loss",
+ "moment_blend": 0.0,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08,
+ "epochs": 100,
+ "batch_size": null,
+ "renewal": "loss",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "validation_source": null,
+ "validation_split": null,
+ "output_dir": "./result/xor",
+ "log_format": "csv",
+ "checkpoint_interval": 25,
+ "save_info": true
+ },
+ "best_training_score": [0.0, 1.0, 0.0],
+ "validation_score": null,
+ "validation_source": null,
+ "validation_sample_count": null
+}
```
-위의 파라미터 기준 10 세대 근처부터 정확도가 100%가 나오는 것을 확인하였습니다
+---
-
+## 프로젝트 구조
-## 2. iris 문제
-
-```python
-loss = 'mean_squared_error'
-
-pso_iris = Optimizer(
- model,
- loss=loss,
- n_particles=100,
- c0=0.35,
- c1=0.7,
- w_min=0.5,
- w_max=0.9,
- negative_swarm=0.1,
- mutation_swarm=0.2,
- particle_min=-3,
- particle_max=3,
-)
-
-best_score = pso_iris.fit(
- x_train,
- y_train,
- epochs=200,
- save=True,
- save_path="./result/iris",
- renewal="acc",
- empirical_balance=False,
- Dispersion=False,
- check_point=25
-)
+```plain
+.
+|-- .github/
+| |-- workflows/
+| |-- pypi.yml # PyPI 게시 워크플로우
+| |-- python-package.yml # GitHub Actions CI 워크플로우
+|-- benchmark_results/ # Protocol 2.0.0 벤치마크 측정 결과 아티팩트
+| |-- pso_v4_benchmark.json
+| |-- pso_v4_main_benchmark.csv
+| |-- pso_v4_ablation_benchmark.csv
+| |-- pso_v4_tuning.json
+| |-- pso_v4_tuning_search.csv
+| |-- pso_v4_tuning_confirmation.csv
+| |-- pso_v4_particle_scaling.csv
+| |-- pso_v4_120p80_replication.json
+| |-- pso_v4_120p80_replication.csv
+| |-- pso_v4_epoch_convergence.json
+| |-- pso_v4_epoch_convergence.csv
+| |-- pso_v4_full_mnist.json
+| |-- pso_v4_full_mnist.csv
+| |-- pso_v4_deep_accuracy.json
+| |-- pso_v4_deep_accuracy.csv
+| |-- pso_v6_heavy_autoresearch.json
+| |-- pso_v6_heavy_autoresearch.csv
+| |-- pso_v7_heavy_cross_split.json
+| |-- pso_v7_heavy_cross_split.csv
+|-- data/ # 실험용 로컬 데이터셋
+|-- example/
+| |-- pso2mnist.ipynb # MNIST Jupyter Notebook 예제
+|-- history_plt/ # 벤치마크 결과 시각화 이미지
+| |-- pso_v4_accuracy.png
+| |-- pso_v4_loss.png
+| |-- pso_v4_rank_heatmap.png
+| |-- pso_v4_runtime.png
+| |-- pso_v4_mnist_ablation.png
+| |-- pso_v4_extended_tuning.png
+| |-- pso_v4_particle_scaling.png
+| |-- pso_v4_epoch_convergence.png
+| |-- pso_v4_full_mnist.png
+| |-- pso_v4_deep_accuracy.png
+| |-- pso_v6_heavy_autoresearch.png
+| |-- pso_v7_heavy_cross_split.png
+|-- pso/ # pso2keras 핵심 라이브러리 코드
+| |-- __init__.py # Optimizer, Particle, __version__ 내보내기
+| |-- _version.py # 패키지 버전 조회
+| |-- _weights.py # PyTorch 파라미터 평탄화/복원 ParameterCodec
+| |-- optimizer.py # Optimizer 클래스 및 5단계 오케스트레이션
+| |-- particle.py # Swarm 파티클 구현
+| |-- plugins.py # 5단계 플러그인 아키텍처 및 메타데이터/스테이지 구현
+|-- test/ # 수동 수렴 실험 및 비교 스크립트
+| |-- benchmark_suite.py # Protocol 2.0.0 종합 벤치마크 자동화 수트
+| |-- tuning_suite.py # Tuning Protocol 1.0.0 검증 선택/확인/스케일링 수트
+| |-- reproduce_scaling.py # 120p×80e 파티클 스케일링 재현성 검증 스크립트
+| |-- epoch_convergence.py # Adaptive Moment 120p 연속 epoch 수렴 진단
+| |-- full_mnist_study.py # 공식 MNIST 60k/10k 전체 학습 진단
+| |-- deep_accuracy_study.py # 공식 MNIST 딥 신경망 원본 이미지/최적화기 비교
+| |-- heavy_pso_autoresearch.py # Heavy PSO 부분공간 반복 실험기
+| |-- evaluate_heavy_autoresearch.py # 고정 Pareto 평가기
+| |-- heavy_pso_cross_split.py # Heavy PSO 교차 분할 실행기
+| |-- evaluate_heavy_cross_split.py # 엄격한 교차 분할 평가기
+| |-- publish_heavy_cross_split.py # 공개 JSON/CSV/PNG 발행기
+| |-- cli.py # CLI 인자 파싱 및 스테이지 헬퍼
+| |-- compare_methods.py # 다종 무브먼트 알고리즘 비교 CLI
+| |-- xor.py
+| |-- iris.py
+| |-- mnist.py
+| |-- fashion_mnist.py
+| |-- digits.py
+| |-- seeds.py
+| |-- bean.py
+|-- tests/ # 자동화 오프라인 pytest 테스트 수트
+| |-- test_plugins.py # 플러그인 레지스트리 및 메타데이터 테스트
+|-- LICENSE
+|-- pyproject.toml # 프로젝트 메타데이터 및 의존성 정의
+|-- README.md
+|-- REPORT.md # PSO v4.0.0 실증 벤치마크 평가 보고서
+|-- uv.lock # 의존성 잠금 파일
```
-위의 파라미터 기준 7 세대에 97%, 35 세대에 99.16%의 정확도를 보였습니다
+---
-
+## 보안 관련 참고 사항
-위의 그래프를 보면 epochs 이 늘어나도 정확도와 loss 가 수렴하지 않는것을 보면 파라미터의 이동 속도가 너무 빠르다고 생각합니다
+> **Note on Credentials**:
+> 이전 README 파일에 포함되어 있던 Sonar 서비스 프로젝트 뱃지 URL에는 인증 토큰 키가 직접 표기되어 있었습니다. 해당 토큰 파라미터는 보안상 이 저장소에서 완전히 제거되었습니다. 기존 노출 토큰의 재발급 및 무효화(Revocation/Rotation) 작업은 해당 Sonar 대시보드 외부 서비스 관리 화면에서 별도로 관리됩니다.
-## 3. mnist 문제
+---
-```python
-loss = 'mean_squared_error'
+## 참고 문헌 (Primary References & DOIs)
-pso_mnist = Optimizer(
- model,
- loss=loss,
- n_particles=500,
- c0= 0.4,
- c1= 0.6,
- w_min= 0.5,
- w_max= 0.8,
- negative_swarm=0.1,
- mutation_swarm=0.2,
- particle_min=-5,
- particle_max=5,
-)
-
-best_score = pso_mnist.fit(
- x_train,
- y_train,
- epochs=200,
- save_info=True,
- log=2,
- log_name="mnist",
- save_path="./result/mnist",
- renewal="acc",
- check_point=25,
-)
-```
-
-위의 파라미터 기준 현재 정확도 63.84%를 보이고 있습니다
-
-
-
-
-
-63%의 정확도가 나타나는 것으로 보아 최적화가 되어가고 있다고 볼 수 있을 것 같습니다.
-
-하지만 정확도가 더 이상 올라가지 않고 정체되는 것으로 보아 조기 수렴하는 문제가 발생하고 있다고 생각합니다.
-
-## Trouble Shooting
-
-> 1. 딥러닝 알고리즘 특성상 weights는 처음 컴파일시 무작위하게 생성된다. weights의 각 지점의 중요도는 매번 무작위로 정해지기에 전역 최적값으로 찾아갈 때 값이 높은 loss를 향해서 상승하는 현상이 나타난다.
->
-> > 따라서 weights의 이동 방법을 더 탐구하거나, weights를 초기화 할때 random 중요도를 좀더 노이즈가 적게 생성하는 방향을 모색해야할 것 같다.
-
--> 고르게 초기화 하기 위해 np.random.uniform 함수를 사용하였습니다
-
-> 2. 지역최적값에 계속 머무르는 조기 수렴 현상이 나타난다. - 30% 정도의 정확도를 가진다
-
--> 지역최적값에 머무르는 것을 방지하기 위해 negative_swarm, mutation_swarm 파라미터를 추가하였습니다 - 현재 63% 정도의 정확도를 보이고 있습니다
-
-> 3. 파티클의 수를 늘리면 전역 최적해에 좀더 가까워지는 현상을 발견하였다. 하지만 파티클의 수를 늘리면 메모리 사용량이 기하급수적으로 늘어난다.
-
--> keras 모델을 사용할때 predict, evaluate 함수를 사용하면 메모리 누수가 발생하는 문제를 찾았습니다. 해결방법을 추가로 찾아보는중 입니다. -> 메모리 누수를 획기적으로 줄여 현재는 파티클의 수를 500개에서 1000개까지 증가시켜도 문제가 없습니다.
--> 추가로 파티클의 수가 적을때에도 전역 최적해를 쉽게 찾는 방법을 찾는중 입니다
-
-> 4. 현재 tensorboard 로 로그 저장시 994개 이상 저장이 안되는 문제가 발생하고 있습니다.
-
--> csv 파일로 저장할 경우 갯수에는 문제가 발생하지 않습니다.
--> 수가 적을때 한 파티클이 지역 최적해에서 머무를 경우 파티클을 초기화 하는 방법이 필요해 보입니다.
-
-> 5. 모델의 크기가 커지면 수렴이 늦어지고 정확도가 떨어지는 현상이 발견되었다. 모델의 크기에 맞는 파라미터를 찾아야할 것 같다.
-
-> 6. EBPSO 의 방식을 추가로 적용을 하였으나 수식을 잘못 적용을 한것인지 기본 pso 보다 더 떨어지는 정확도를 보이고 있다. (현재 수정중)
-
-### 개인적인 생각
-
-> 머신러닝 분류 방식에 존재하는 random forest 방식을 이용하여, 오차역전파 함수를 최적화 하는 방법이 있을것 같습니다
->
-> > pso 와 random forest 방식이 매우 유사하다고 생각하여 학습할 때 뿐만 아니라 예측 할 때도 이러한 방식으로 사용할 수 있을 것 같습니다
-
-# 참고 자료
-
-[1]: [A partilce swarm optimization algorithm with empirical balance stategy](https://www.sciencedirect.com/science/article/pii/S2590054422000185#bib0005)
-[2]: [psokeras](https://github.com/mike-holcomb/PSOkeras)
-[3]: [PSO의 다양한 영역 탐색과 지역적 미니멈 인식을 위한 전략](https://koreascience.kr/article/JAKO200925836515680.pdf)
-[4]: [PC 클러스터 기반의 Multi-HPSO를 이용한 안전도 제약의 경제 급전](https://koreascience.kr/article/JAKO200932056732373.pdf)
-[5]: [Particle 2-Swarm Optimization for Robust Search](https://s-space.snu.ac.kr/bitstream/10371/29949/3/management_information_v18_01_p01.pdf)
+1. Kennedy, J., & Eberhart, R. (1995). *Particle swarm optimization*. In Proceedings of ICNN'95 - International Conference on Neural Networks (Vol. 4, pp. 1942-1948). IEEE. DOI: [10.1109/ICNN.1995.488968](https://doi.org/10.1109/ICNN.1995.488968)
+2. Shi, Y., & Eberhart, R. (1998). *A modified particle swarm optimizer*. In 1998 IEEE International Conference on Evolutionary Computation Proceedings. IEEE World Congress on Computational Intelligence (pp. 69-73). IEEE. DOI: [10.1109/ICEC.1998.699146](https://doi.org/10.1109/ICEC.1998.699146)
+3. Clerc, M., & Kennedy, J. (2002). *The particle swarm-explosion, stability, and convergence in a multidimensional complex space*. IEEE Transactions on Evolutionary Computation, 6(1), 58-73. DOI: [10.1109/4235.985692](https://doi.org/10.1109/4235.985692)
+4. Mendes, R., Kennedy, J., & Neves, J. (2004). *The fully informed particle swarm: simpler, maybe better*. IEEE Transactions on Evolutionary Computation, 8(3), 204-210. DOI: [10.1109/TEVC.2004.826074](https://doi.org/10.1109/TEVC.2004.826074)
+5. Liang, J. J., Qin, A. K., Suganthan, P. N., & Baskar, S. (2006). *Comprehensive learning particle swarm optimizer for global optimization of multimodal functions*. IEEE Transactions on Evolutionary Computation, 10(3), 281-295. DOI: [10.1109/TEVC.2005.857610](https://doi.org/10.1109/TEVC.2005.857610)
+6. Kennedy, J. (2003). *Bare bones particle swarms*. In Proceedings of the 2003 IEEE Swarm Intelligence Symposium (pp. 80-87). IEEE. DOI: [10.1109/SIS.2003.1202251](https://doi.org/10.1109/SIS.2003.1202251)
+7. Zhang, J.-R., Zhang, J., Lok, T.-M., & Lyu, M. R. (2007). *A hybrid particle swarm optimization–back-propagation algorithm for feedforward neural network training*. Applied Mathematics and Computation, 185(2), 1026-1037. DOI: [10.1016/j.amc.2006.07.025](https://doi.org/10.1016/j.amc.2006.07.025) (Hybrid PSO-BP Classical Foundations)
+8. Kennedy, J., & Mendes, R. (2002). *Population structure and particle swarm performance*. In Proceedings of the 2002 Congress on Evolutionary Computation (Vol. 2, pp. 1671-1676). IEEE. DOI: [10.1109/CEC.2002.1004493](https://doi.org/10.1109/CEC.2002.1004493)
+9. Sun, J., Feng, B., & Xu, W. (2004). *Particle swarm optimization with particles having quantum behavior*. In Proceedings of the 2004 Congress on Evolutionary Computation (pp. 325-331). IEEE. DOI: [10.1109/CEC.2004.1330875](https://doi.org/10.1109/CEC.2004.1330875)
diff --git a/REPORT.md b/REPORT.md
new file mode 100644
index 0000000..9a72cc5
--- /dev/null
+++ b/REPORT.md
@@ -0,0 +1,796 @@
+# PSO v4.0.0 실증 벤치마크 평가 보고서 (Benchmark 2.0.0 + Tuning 1.0.0 + Replication 1.0.0 + Epoch Convergence 1.0.0 + Full MNIST 1.0.0 + Deep Accuracy 1.0.0 + MNIST-PSO-RAW-V5 1.0.0 + MNIST-PSO-RAW-V6 1.0.0 + HEAVY-TASK-PSO-V6 1.0.0 + HEAVY-PSO-CROSS-SPLIT 1.0.0)
+
+## 1. 요약 및 핵심 발견사항 (Executive Findings)
+
+본 보고서는 `pso2keras` 라이브러리의 v4.0.0 5단계 플러그인 아키텍처 기반 미분 무관(Derivative-Free) Particle Swarm Optimization (PSO) 알고리즘 수렴 성능 및 특성에 대한 종합 실증 평가 결과입니다. 벤치마크 프로토콜 v2.0.0에 따라 총 225회의 독립 측정 실행(메인 벤치마크 7기법 × 5워크로드 × 5시드 = 175회, MNIST Ablation 10프로필 × 5시드 = 50회)을 수행하였으며, 모든 실행은 에러 없이 100% 성공적으로 완료되었습니다.
+
+추가로 Tuning Protocol 1.0.0에서 32개 하이퍼파라미터 후보의 검증 선택, 5개 기법의 held-out 확인, `adaptive_moment` 파티클 스케일링을 수행했습니다. 이 확장 연구는 161개 결과 레코드(96 search + 25 confirmation + 40 scaling)를 포함하며, 공유 30×80 scaling 셀을 재사용했으므로 실제 scaling 적합 실행은 35회입니다. 이후 120×80 exact replay/fresh-seed 10회, 같은 시드 5개의 240-epoch subset 궤적, 공식 MNIST 60,000/10,000 전체 split의 240-epoch 궤적 5회를 각각 별도 프로토콜로 실행했습니다. Deep Accuracy Protocol 1.0.0은 아키텍처 레인 9개와 최적화기 레인 9개의 논리 레코드를 포함하며, 최적화기 레인의 `adam_only` 3개는 아키텍처 레인의 Compact CNN 결과를 명시적으로 재사용하므로 실제 고유 학습 워크플로는 15개입니다. 이 후속 실행들은 기존 161개 Tuning Protocol 레코드나 225회 Protocol 2.0.0 결과에 합산하지 않습니다.
+
+HEAVY-TASK-PSO-V6 1.0.0은 공식 test split을 사용하지 않고 MNIST/FashionMNIST의 train 60,000개를 각각 search 50,000/validation 10,000으로 분할해, Compact CNN(9,098 params)과 WideCNN(55,338 params)의 전가중치 PSO 실행 가능성을 추가로 평가했습니다. 단일시드 16-cell screen 뒤 G8과 workload별 validation-selected normalized 방법을 3개 시드로 확인했으며, 이 결과는 기존 프로토콜 실행 수에 합산하지 않습니다.
+
+### 핵심 평가 요약
+1. **고전 무브먼트 기법의 강세**: 5개 워크로드 종합 평균 순위에서 `constriction` (수축 계수 PSO)과 `inertia` (관성 가중치 감쇄 PSO)가 평가 정확도 평균 순위 **1.60**으로 공동 1위를 기록했습니다. 손실(Loss) 측면에서는 `constriction`이 평균 순위 **1.60**으로 `inertia` (**1.80**) 대비 더 낮은 손실 수렴 성향을 나타냈습니다.
+2. **미분 기반 후처리(Adam)의 효과**: MNIST 소형 분류 모델 실험에서 하이브리드 경사하강 미세조정(`tuned_adam_100_lr.01`)을 적용할 경우 검증 정확도 **85.58% ± 0.24%**를 기록하여 최고 성과를 달성했습니다. 다만, 이는 역전파 경사도(`loss.backward()`)를 활용하는 하이브리드 방식입니다.
+3. **미분 무관 Ablation 탐색 최고 성과**: pure derivative-free 기법 중 MNIST Ablation 최고 검증 정확도는 `adaptive_moment_.10` (적응형 경로 모멘트 혼합비 0.10)로 **63.00% ± 1.83%**를 기록했습니다 (단, 검증 손실은 **1.243339**로 `inertia_tuned`의 **1.236600** 대비 약간 높음).
+4. **평가 방식 및 샘플 수 교란 요인**: 미분 무관 ablation 중 최저 검증 손실은 `tuned_full_evaluation`의 **1.179009 ± 0.050059**였으나, 이는 고정 서브셋(2,000개)이 아닌 전체 학습 데이터(3,000개) 평가 및 배치 처리 차이에 따른 교란 요인(Confound)이 반영된 수치입니다.
+5. **파티클 재초기화(Particle Reset)**: `tuned_particle_reset` 프로필은 측정된 시드 세트(46~50)에서 `inertia_tuned`와 동일한 최종 성능 수치(**61.62% / 1.236600**)를 기록했습니다. 재초기화 이벤트 수를 별도로 계측하지 않았으므로, 이벤트가 없었는지 또는 최종 전역 최적해에 영향을 주지 않았는지는 이 결과만으로 구분할 수 없습니다.
+6. **확장 튜닝의 동일 예산 확인**: 파티클 30개 × 80세대 held-out 확인에서 `local_best`가 **62.64% ± 2.94%**, `inertia`가 **62.30% ± 3.01%**, `adaptive_moment`가 **61.06% ± 0.91%**를 기록했습니다. 따라서 Adaptive Moment는 이 동일 예산 비교의 최상위 기법이 아닙니다.
+7. **Adaptive Moment 파티클 증가**: 80세대를 유지하면서 파티클을 30개에서 120개로 늘리면 정확도가 **62.12%에서 72.34%**로 상승했지만 particle-evaluations와 fit 시간도 각각 4배와 **4.16배**로 증가했습니다. 약 2,400 particle-epochs를 고정하면 파티클 증가와 세대 감소 조합의 정확도는 오히려 낮아졌습니다.
+8. **120×80 재현성 확인**: 동일 시드 71~75 exact replay는 baseline과 같은 **72.34% ± 1.82%**를 재현했고 시드별 최대 차이는 **0.00%p**였습니다. 독립 시드 81~85는 **73.60% ± 1.66%**로 baseline 대비 **+1.26%p**였으며, 사전 선언한 ±3%p 및 95% t-신뢰구간 중첩 조건을 모두 충족했습니다.
+9. **Epoch 80은 조기 수렴 지점이 아님**: 120개 파티클의 연속 실행을 240세대까지 늘리자 테스트 정확도가 **72.34%에서 83.52%**로 **+11.18%p** 상승하고 training best loss가 **47.30%** 감소했습니다. 200→240에서도 loss가 **6.68%** 감소하고 정확도가 **+0.94%p** 상승해 epoch 240에서도 완전한 plateau는 확인되지 않았습니다.
+10. **전체 MNIST 학습 결과**: 공식 train 60,000개를 모든 파티클의 매 epoch fitness에 사용하고 test 10,000개 전체를 평가했습니다. 120 particles × 240 epochs에서 정확도는 **87.70% ± 0.36%**, 테스트 loss는 **0.412078 ± 0.006848**이었습니다. Epoch 200→240에서도 정확도가 **+0.85%p**, training loss가 **6.13%** 개선되어 plateau는 확인되지 않았습니다.
+11. **원본 MNIST 이미지 및 딥 신경망 아키텍처/최적화 기법 평가 (Deep Accuracy 1.0.0)**: PCA 없이 공식 train 60,000개와 test 10,000개 원본 $1 \times 28 \times 28$ 입력을 평가했습니다($n=3$, seeds 101~103). Adam 10 epochs에서 Raw Linear(7,850 params)는 **92.45% ± 0.10%**, Raw MLP(109,386 params)는 **97.70% ± 0.08%**, Compact CNN(9,098 params)은 **98.53% ± 0.16%**였고 CNN은 모든 시드가 5 epochs 이내 98%에 도달했습니다. 같은 CNN에서 30 particles × 40 generations·fixed-2k all-weight PSO는 **36.76% ± 3.76%**, PSO→Adam은 **97.30% ± 0.75%**였습니다. 측정한 예산에서는 전가중치 PSO와 PSO 초기화가 pure Adam을 대체하거나 개선하지 못했습니다.
+12. **V5 탐색 구조 회귀 원인 분리 (MNIST-PSO-RAW-V6 1.0.0)**: 공식 test split을 로드하지 않고 train 60,000개를 search 50,000/validation 10,000으로 나눈 뒤, Compact CNN 전가중치 PSO의 탐색 구조 9개를 비교했습니다. 3-시드 확인에서 V5 구조 G0은 **79.53% ± 0.58% / NLL 0.689687**, 기존 `Optimizer` 제어군 G8은 **84.92% ± 0.99% / 0.481440**이었습니다. mutation·초기 속도·normalized ±6 경계를 묶은 G5/G6은 각각 **84.24% / 0.510297**, **84.25% / 0.503809**로 사전 회복 기준을 충족했습니다. 단일시드 screen은 mutation과 경계 확장을 유력 요인으로 지목하지만 개별 3-시드 인과 확인은 아직 수행하지 않았습니다.
+13. **더 무거운 영상 태스크 실행 가능성 (HEAVY-TASK-PSO-V6 1.0.0)**: 파라미터 수를 **9,098→55,338(6.08배)**로 늘리고 FashionMNIST를 추가한 네 workload에서 G8과 screen-selected G5/G6의 24개 확인 실행이 모두 finite하게 완료됐습니다. 사전 기준(초기 모델 대비 validation NLL 20% 이상 감소와 accuracy 20%p 이상 상승)은 8개 workload-method 집계가 모두 통과했습니다. 그러나 12 particles × 80 epochs·fixed-10k에서 최종 정확도는 **41.03~49.15%**에 그쳐, 이는 계산상 최적화 가능성이지 실용적 학습 성능이나 Adam 대체 가능성을 의미하지 않습니다.
+14. **Heavy PSO 교차 분할 강건성 검증 실패 (HEAVY-PSO-CROSS-SPLIT 1.0.0)**: 개발 분할 2개(20260905/20260906) 및 시드 101~103, 매칭 baseline 재실행 조건(12p×80e×fixed10k)에서 동결 정책 `fixed_global_hybrid_v3`를 교차 평가한 결과, 전체 정확도 개선은 +0.1533%p, NLL 감소는 0.5546%에 그쳤고 최악 accuracy 회귀 -7.1767%p, 최악 NLL 회귀 +14.5682%, MNIST Wide acc -0.3617%p(NLL 2.4600% 악화)로 게이트를 통과하지 못해 실패(FAIL)로 판정되었습니다. 총 8회 결정 탐색(9개 개발 변형) 중 최상위 스코어 후보(Iteration 5, 스코어 -185.610686)도 MNIST Wide acc -2.6633%p(NLL 2.1874% 악화)로 탈락했습니다. 이에 따라 보존 정책은 `null`로 확정되었고 확인 분할(20260907) 실행은 과학적 규칙에 따라 보류되었으며 공식 test split은 0회 로드/평가되었습니다 (총 432 runs, 414,720 queries, 41.472억 샘플 평가, 3162.9717s).
+
+---
+
+## 2. 실험 환경 및 워크로드 스펙 (Hardware, Software & Workload Spec)
+
+### 2.1 하드웨어 및 소프트웨어 프로비넌스
+
+| 환경 항목 | 세부 사양 / 버전 |
+| --- | --- |
+| **플랫폼 (OS)** | macOS 26.5.2 (Darwin 25.5.0 arm64) |
+| **프로세서 (CPU/GPU)** | Apple M5 Max (System Apple Silicon, MPS 가속) |
+| **Python 버전** | 3.11.15 |
+| **PyTorch 버전** | 2.13.0 (`device="mps"`) |
+| **패키지 버전** | `pso2keras` v4.0.0 |
+| **벤치마크 프로토콜** | Protocol v2.0.0 |
+
+### 2.2 워크로드 및 신경망 모델 매트릭스
+
+본 벤치마크는 비선형 논리 회로(XOR), 소형 다변량 표형 데이터(Iris, Seeds), 중형 이미지 수치 데이터(Digits), PCA 32차원 축소 MNIST 데이터셋을 대상으로 수행되었습니다.
+
+| 워크로드 | 데이터 크기 (학습/검증) | 모델 구조 | 파라미터 수 | 손실 함수 및 작업 | 파티클 수 ($N$) | 세대 수 ($T$) | 평가 대상 집합 | 시드 범위 |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| **XOR** | 4 / 4 | `Linear(2,4) - Tanh - Linear(4,1)` | 17 | `BCEWithLogitsLoss` (Binary) | 24 | 80 | Train Eval | 41 ~ 45 |
+| **Iris** | 120 / 30 | `Linear(4,10) - ReLU - Linear(10,10) - ReLU - Linear(10,3)` | 193 | `CrossEntropyLoss` (Multiclass) | 24 | 60 | Held-out Eval | 41 ~ 45 |
+| **Seeds** | 168 / 42 | `Linear(7,16) - ReLU - Linear(16,32) - ReLU - Linear(32,3)` | 771 | `CrossEntropyLoss` (Multiclass) | 24 | 60 | Held-out Eval | 41 ~ 45 |
+| **Digits** | 1,437 / 360 | `Linear(64,12) - ReLU - Linear(12,10) - ReLU - Linear(10,10)` | 1,020 | `CrossEntropyLoss` (Multiclass) | 24 | 50 | Held-out Eval | 41 ~ 45 |
+| **MNIST** | 3,000 / 1,000 (PCA32) | `Linear(32,10)` | 330 | `CrossEntropyLoss` (Multiclass) | 30 | 80 | Held-out Eval | 41 ~ 45 |
+
+> **참고**: MNIST 실험은 784차원 원본 이미지 텐서가 아닌 PCA 32차원 로짓 분류기 `Linear(32,10)` 환경(학습 3,000개, 검증 1,000개)에서 수행되었습니다.
+> **타이밍 예산 및 웜업**: 각 측정은 별도의 모델과 Optimizer로 기법별 비측정 웜업(PSO 2세대)을 수행한 뒤, 동일 시드로 측정 대상을 다시 생성하여 `fit()` 호출만 측정했습니다. Adam 프로필의 웜업은 refinement 1세대를 포함하며, 메인 미분 무관 실험의 웜업은 refinement를 사용하지 않습니다.
+
+---
+
+## 3. 메인 벤치마크 평가 결과 (Main Benchmark Matrix)
+
+7가지 주요 PSO 무브먼트 기법(`original`, `inertia`, `constriction`, `fips`, `clpso`, `bare_bones`, `adaptive_moment`)에 대한 5개 워크로드별 5-시드 평균 및 표준편차(Mean ± SD, $n=5$) 결과입니다.
+
+### 3.1 정확도 Matrix (Eval Accuracy %, Mean ± SD)
+
+| 워크로드 (평가 구분) | original | inertia | constriction | fips | clpso | bare_bones | adaptive_moment |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| **XOR** (Train) | 100.00% ± 0.00% | 100.00% ± 0.00% | **100.00% ± 0.00%** | 75.00% ± 25.00% | 60.00% ± 13.69% | 100.00% ± 0.00% | 100.00% ± 0.00% |
+| **Iris** (Held-out) | 92.00% ± 8.69% | **94.00% ± 2.79%** | 94.00% ± 3.65% | 74.00% ± 5.48% | 79.33% ± 7.60% | 84.67% ± 5.58% | 84.67% ± 7.67% |
+| **Seeds** (Held-out) | 87.62% ± 4.26% | **91.43% ± 5.22%** | 89.05% ± 9.16% | 88.57% ± 3.53% | 85.71% ± 2.92% | 87.14% ± 6.86% | 89.05% ± 4.64% |
+| **Digits** (Held-out) | 16.44% ± 2.23% | 30.33% ± 6.17% | **37.28% ± 1.79%** | 24.94% ± 6.15% | 20.78% ± 5.06% | 19.00% ± 5.63% | 26.78% ± 1.83% |
+| **MNIST** (Held-out) | 14.40% ± 1.66% | 46.84% ± 7.53% | **52.00% ± 4.62%** | 21.06% ± 4.81% | 20.68% ± 2.28% | 41.26% ± 3.80% | 26.20% ± 1.04% |
+
+### 3.2 손실 Matrix (Eval Raw Loss, Mean ± SD)
+
+| 워크로드 (평가 구분) | original | inertia | constriction | fips | clpso | bare_bones | adaptive_moment |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| **XOR** (Train) | 0.004558 ± 0.002672 | 0.004431 ± 0.003308 | **0.004086 ± 0.002357** | 0.546355 ± 0.059307 | 0.548166 ± 0.031946 | 0.082100 ± 0.056963 | 0.190431 ± 0.178122 |
+| **Iris** (Held-out) | 0.222324 ± 0.155767 | **0.106901 ± 0.053063** | 0.171796 ± 0.076965 | 0.605010 ± 0.060601 | 0.448270 ± 0.053877 | 0.405791 ± 0.172336 | 0.349701 ± 0.178108 |
+| **Seeds** (Held-out) | 0.492240 ± 0.433653 | 0.331656 ± 0.342636 | 0.351420 ± 0.388200 | 0.383732 ± 0.103951 | 0.469817 ± 0.073254 | 0.421920 ± 0.120052 | **0.315947 ± 0.120895** |
+| **Digits** (Held-out) | 2.269628 ± 0.025331 | 1.980667 ± 0.143070 | **1.765113 ± 0.057309** | 2.064165 ± 0.091569 | 2.204543 ± 0.023215 | 2.250203 ± 0.084448 | 2.108837 ± 0.023357 |
+| **MNIST** (Held-out) | 2.428194 ± 0.091877 | 1.716089 ± 0.260764 | **1.507968 ± 0.149152** | 2.223230 ± 0.073048 | 2.285833 ± 0.068177 | 1.965562 ± 0.175909 | 2.219058 ± 0.104724 |
+
+### 3.3 워크로드별 최고 성과 기법 요약 (Per-workload Winners)
+
+| 워크로드 | 최고 정확도 기법 (Eval Acc) | 최저 손실 기법 (Eval Loss) | 비고 |
+| --- | --- | --- | --- |
+| **XOR** | `constriction` (100.00% ± 0.00%) | `constriction` (0.004086 ± 0.002357) | 5개 기법 100% 동률 (손실로 순위 구분) |
+| **Iris** | `inertia` (94.00% ± 2.79%) | `inertia` (0.106901 ± 0.053063) | `constriction`과 정확도 동률, 손실로 순위 구분 |
+| **Seeds** | `inertia` (91.43% ± 5.22%) | `adaptive_moment` (0.315947 ± 0.120895) | 정확도 inertia 우수, 손실 AM 우수 |
+| **Digits** | `constriction` (37.28% ± 1.79%) | `constriction` (1.765113 ± 0.057309) | 고차원 다중 분류에서 수축 계수 우수 |
+| **MNIST** | `constriction` (52.00% ± 4.62%) | `constriction` (1.507968 ± 0.149152) | 이 고정 예산에서 정확도와 손실 모두 1위 |
+
+### 3.4 평균 순위 및 수렴 실행 시간 (Ranks & Warmed Runtime)
+
+각 워크로드 내에서 1위(최고)부터 7위(최저)까지 순위를 부여한 후 5개 워크로드에 대해 평균한 결과 및 MPS 디바이스 웜업 완료 후 측정된 실행 시간입니다.
+
+| 기법 (`method`) | 정확도 순위 목록 [XOR, Iris, Seeds, Digits, MNIST] | 평균 정확도 순위 | 손실 순위 목록 [XOR, Iris, Seeds, Digits, MNIST] | 평균 손실 순위 | 평균 실행 시간 ($n=25$) |
+| --- | --- | --- | --- | --- | --- |
+| **`constriction`** | [1, 2, 3, 1, 1] | **1.60** | [1, 2, 3, 1, 1] | **1.60** | 2.0821s ± 0.766s |
+| **`inertia`** | [2, 1, 1, 2, 2] | **1.60** | [2, 1, 2, 2, 2] | **1.80** | 1.9824s ± 0.614s |
+| **`adaptive_moment`** | [5, 4, 2, 3, 4] | **3.60** | [5, 4, 1, 4, 4] | **3.60** | 2.1264s ± 0.874s |
+| **`bare_bones`** | [4, 5, 6, 6, 3] | **4.80** | [4, 5, 5, 6, 3] | **4.60** | 2.2476s ± 0.724s |
+| **`original`** | [3, 3, 5, 7, 7] | **5.00** | [3, 3, 7, 7, 7] | **5.40** | 2.1112s ± 0.857s |
+| **`fips`** | [6, 7, 4, 4, 5] | **5.20** | [6, 7, 4, 3, 5] | **5.00** | 2.5636s ± 0.708s |
+| **`clpso`** | [7, 6, 7, 5, 6] | **6.20** | [7, 6, 6, 5, 6] | **6.00** | 2.3507s ± 0.726s |
+
+> **핵심 요약**: `inertia`와 `constriction`은 평균 정확도 순위 **1.60**으로 공동 1위를 기록했습니다. 평균 손실 순위는 `constriction` **1.60**, `inertia` **1.80**이었으며, 이는 이 다섯 워크로드의 표본 평균 서열입니다.
+
+---
+
+## 4. 메인 시각화 차트 (Main Figures)
+
+벤치마크 결과 시각화 차트는 `history_plt/` 디렉터리에 저장되어 있습니다.
+
+| 정확도 비교 (Accuracy) | 손실 비교 (Loss) |
+| --- | --- |
+|  |  |
+
+| 순위 히트맵 (Rank Heatmap) | 실행 시간 비교 (Runtime) |
+| --- | --- |
+|  |  |
+
+---
+
+## 5. MNIST Ablation 연구 (MNIST 10-Profile Ablation Study)
+
+MNIST PCA32 `Linear(32,10)` 워크로드(파티클 30, 세대 80, 시드 46~50)에서 초기화, 적합도 평가, 수렴 제어, 미세조정, 적응형 경로 모멘트 하이퍼파라미터 변형 10개 프로필을 비교 분석하였습니다.
+
+### 5.1 Ablation 종합 성과 매트릭스
+
+| 프로필 식별자 (`profile`) | 검증 정확도 (Eval Acc) | 검증 손실 (Eval Loss) | 학습 정확도 (Train Acc) | 학습 손실 (Train Loss) | 실행 시간 (Runtime) | Acc 순위 | Loss 순위 |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| `tuned_adam_100_lr.01` | **85.58% ± 0.24%** | **0.470271 ± 0.011931** | 91.58% ± 0.39% | 0.298524 ± 0.012987 | 4.991s ± 0.434s | 1 | 1 |
+| `adaptive_moment_.10` | **63.00% ± 1.83%** | 1.243339 ± 0.102561 | 70.99% ± 1.28% | 0.978244 ± 0.021198 | 4.287s ± 0.289s | 2 | 5 |
+| `tuned_full_evaluation` | **62.54% ± 2.80%** | **1.179009 ± 0.050059** | 68.79% ± 1.07% | 1.005140 ± 0.028281 | 3.377s ± 0.469s | 3 | 2 |
+| `inertia_tuned` (기준) | 61.62% ± 5.13% | 1.236600 ± 0.124281 | 69.31% ± 2.93% | 0.999514 ± 0.075496 | 3.132s ± 0.409s | 4 | 3 |
+| `tuned_particle_reset` | 61.62% ± 5.13% | 1.236600 ± 0.124281 | 69.31% ± 2.93% | 0.999514 ± 0.075496 | 4.176s ± 0.449s | 5 | 4 |
+| `tuned_no_mutation` | 60.42% ± 3.04% | 1.249836 ± 0.084985 | 66.86% ± 1.28% | 1.074396 ± 0.043372 | 3.348s ± 0.343s | 6 | 6 |
+| `tuned_uniform_initialization` | 56.98% ± 2.40% | 1.619196 ± 0.157329 | 61.60% ± 0.90% | 1.345857 ± 0.048557 | 4.307s ± 0.443s | 7 | 8 |
+| `adaptive_moment_.25` | 56.32% ± 2.94% | 1.499979 ± 0.119449 | 63.79% ± 2.42% | 1.228023 ± 0.088967 | 3.291s ± 0.426s | 8 | 7 |
+| `adaptive_moment_.50` | 51.86% ± 3.91% | 1.683781 ± 0.121571 | 57.05% ± 2.75% | 1.463700 ± 0.097485 | 3.203s ± 0.270s | 9 | 9 |
+| `inertia_canonical` | 46.76% ± 2.44% | 1.720983 ± 0.118092 | 52.77% ± 2.89% | 1.528197 ± 0.079997 | 3.120s ± 0.306s | 10 | 10 |
+
+### 5.2 MNIST Ablation 시각화 차트
+
+
+
+### 5.3 `inertia_tuned` 기준 상대 델타 (Paired Deltas vs `inertia_tuned`)
+
+`inertia_tuned` 프로필(Eval Acc: **61.62%**, Eval Loss: **1.236600**, Runtime: **3.132s**) 대비 각 변형 프로필의 절대 편차량입니다:
+
+1. **`inertia_canonical` vs `inertia_tuned`**:
+ - $\Delta$ Eval Acc: **-14.86%p** (46.76% vs 61.62%)
+ - $\Delta$ Eval Loss: **+0.484383** (1.720983 vs 1.236600)
+ - $\Delta$ Runtime: **-0.012s** (3.120s vs 3.132s)
+ - *해석*: 인지·사회 계수, 관성, 속도 제한 및 변이를 함께 조정한 튜닝 프로필이 이 PCA32 워크로드에서 canonical inertia 프로필보다 14.86%p 높은 평균 정확도를 기록했습니다. 개별 요소의 기여는 아래 단일요인 비교로만 제한적으로 해석해야 합니다.
+2. **`tuned_no_mutation` vs `inertia_tuned`**:
+ - $\Delta$ Eval Acc: **-1.20%p** (60.42% vs 61.62%)
+ - $\Delta$ Eval Loss: **+0.013236** (1.249836 vs 1.236600)
+ - $\Delta$ Runtime: **+0.216s** (3.348s vs 3.132s)
+ - *해석*: `mutation_swarm=0.02`를 제거한 프로필의 평균 정확도가 1.20%p 낮았습니다. $n=5$ 변동 범위가 겹치므로, 변이가 국소 최적점 탈출을 입증했다고 단정할 수는 없습니다.
+3. **`tuned_full_evaluation` vs `inertia_tuned`**:
+ - $\Delta$ Eval Acc: **+0.92%p** (62.54% vs 61.62%)
+ - $\Delta$ Eval Loss: **-0.057591** (1.179009 vs 1.236600)
+ - $\Delta$ Runtime: **+0.245s** (3.377s vs 3.132s)
+ - *해석*: 미분 무관 프로필 중 최저 손실(**1.179009**)을 기록했습니다. 단, 2,000개 고정 서브셋 평가인 `inertia_tuned`와 달리 3,000개 전체 데이터셋 평가 방식이 적용되어 샘플 수 차이 및 배치 연산 차이에 따른 교란 요인(Confound)이 존재합니다.
+4. **`tuned_uniform_initialization` vs `inertia_tuned`**:
+ - $\Delta$ Eval Acc: **-4.64%p** (56.98% ± 2.40% vs 61.62%)
+ - $\Delta$ Eval Loss: **+0.382596** (1.619196 vs 1.236600)
+ - $\Delta$ Runtime: **+1.175s** (4.307s vs 3.132s)
+ - *해석*: PyTorch 가중치 기준 노이즈 부가 대신 유니폼 무작위 위치 초기화를 사용할 경우 신경망 적합도 탐색에 불리함을 나타냅니다.
+5. **`tuned_particle_reset` vs `inertia_tuned`**:
+ - $\Delta$ Eval Acc: **+0.00%p** (61.62% vs 61.62%)
+ - $\Delta$ Eval Loss: **0.000000** (1.236600 vs 1.236600)
+ - $\Delta$ Runtime: **+1.045s** (4.176s vs 3.132s)
+ - *해석*: 최종 평가지표는 기준과 완전히 동일했지만 재초기화 이벤트 텔레메트리가 없으므로, 정체 조건 미충족과 전역 최적해 비영향을 구분할 수 없습니다. 추가 이벤트 계측 없이 수렴 개선 효과를 주장하지 않습니다.
+6. **`tuned_adam_100_lr.01` vs `inertia_tuned`**:
+ - $\Delta$ Eval Acc: **+23.96%p** (85.58% vs 61.62%)
+ - $\Delta$ Eval Loss: **-0.766329** (0.470271 vs 1.236600)
+ - $\Delta$ Runtime: **+1.859s** (4.991s vs 3.132s)
+ - *해석*: 전체 10개 프로필 중 가장 높은 정확도와 가장 낮은 손실을 기록했습니다. 다만, 본 기법은 순수 미분 무관 기법이 아닌 PSO 수렴 위치 후 100 세대 역전파 Adam 미세조정(Refinement)을 수행하는 경사도 활용(Gradient-assisted) 하이브리드 기법입니다.
+7. **`adaptive_moment_.10` vs `inertia_tuned`**:
+ - $\Delta$ Eval Acc: **+1.38%p** (63.00% vs 61.62%)
+ - $\Delta$ Eval Loss: **+0.006739** (1.243339 vs 1.236600)
+ - $\Delta$ Runtime: **+1.155s** (4.287s vs 3.132s)
+ - *해석*: 미분 무관(Derivative-Free) 프로필 중 **최고 검증 정확도(63.00% ± 1.83%)**를 기록했습니다. 정확도는 `inertia_tuned` 대비 1.38%p 우수하나, 검증 손실은 1.243339로 `inertia_tuned` (1.236600) 대비 약간 높게 유지되었습니다.
+8. **`adaptive_moment_.25` 및 `.50` vs `inertia_tuned`**:
+ - `.25`: $\Delta$ Eval Acc **-5.30%p** (56.32%), $\Delta$ Eval Loss **+0.263379** (1.499979)
+ - `.50`: $\Delta$ Eval Acc **-9.76%p** (51.86%), $\Delta$ Eval Loss **+0.447181** (1.683781)
+ - *해석*: 이 3개 혼합비 설정에서는 $\lambda$가 0.10에서 0.25, 0.50으로 증가할수록 평균 정확도가 낮아지고 손실이 높아지는 패턴이 관찰되었습니다. 다른 모델·예산으로 일반화되는 단조 관계로 해석하지 않습니다.
+
+## 6. 확장 튜닝 및 파티클 스케일링 (Tuning Protocol 1.0.0)
+
+### 6.1 방법론과 데이터 분리
+
+- **모델/데이터**: MNIST 첫 학습 3,000개와 테스트 1,000개, PCA32 whitening, `Linear(32,10)`, `CrossEntropyLoss`.
+- **Search**: 첫 3,000개를 stratified 2,400 inner-train / 600 validation으로 분리하고 PCA를 inner-train에만 적합했습니다. 5개 기법의 32개 후보를 파티클 30개, 80세대, 시드 51~53에서 비교하고 평균 validation accuracy 내림차순, 동률 시 loss 오름차순으로 기법별 후보를 선택했습니다.
+- **Confirmation**: 선택된 기법별 후보를 전체 학습 3,000개로 다시 적합했습니다. PCA도 전체 학습 데이터에만 다시 적합하고 search에 사용하지 않은 테스트 1,000개를 시드 61~65에서 평가했습니다.
+- **Scaling**: 선택된 Adaptive Moment 후보를 시드 71~75에서 파티클 30/60/90/120개로 평가했습니다. 80세대 고정과 약 2,400 particle-epochs 고정을 분리했습니다.
+- **공통 조건**: `fixed_subset=2000`, batch 1,000, 반사 경계 ±3, 미분 무관, Adam refinement 없음. 시간은 기법별 비계측 웜업 후 `fit()`만 측정했습니다.
+
+Search가 테스트셋을 사용하지 않도록 데이터와 PCA 적합 범위를 분리했습니다. 모든 161개 레코드는 MPS에서 완료되었고 오류는 0건이었습니다. 총 계측 fit 시간은 search **259.479s**, confirmation **64.745s**, 중복을 제외한 scaling **184.978s**였습니다.
+
+### 6.2 검증 선택 결과
+
+| 기법 | 선택 후보 | Validation Accuracy | Validation Loss |
+| --- | --- | ---: | ---: |
+| `local_best` | `local_best_r4_constant` | **72.44%** | **0.944913** |
+| `constriction` | `constriction_c205_canonical` | 70.89% | 0.984401 |
+| `adaptive_moment` | `am_b0.06_s0.5` | 70.17% | 0.950972 |
+| `inertia` | `inertia_asymmetric` | 69.72% | 1.029132 |
+| `quantum` | `quantum_beta_0.4_0.9` | 56.50% | 1.337709 |
+
+Adaptive Moment 선택값은 $c_0=c_1=1.49618$, $w=0.7298$, velocity limit ratio 0.025, mutation 0.02, `moment_blend=0.06`, `moment_step_size=0.5`, $\beta_1=0.9$입니다. 이는 저장소 기본값이 아니라 이 search 범위에서 선택된 후보입니다.
+
+### 6.3 Held-out 테스트 확인
+
+| 기법 | 선택 후보 | Test Accuracy (Mean ± SD) | Test Loss (Mean ± SD) | Fit Time (Mean ± SD) |
+| --- | --- | ---: | ---: | ---: |
+| `local_best` | `local_best_r4_constant` | **62.64% ± 2.94%** | **1.211368 ± 0.059575** | 2.512s ± 0.048s |
+| `inertia` | `inertia_asymmetric` | 62.30% ± 3.01% | 1.212971 ± 0.078548 | 2.570s ± 0.035s |
+| `adaptive_moment` | `am_b0.06_s0.5` | 61.06% ± 0.91% | 1.229627 ± 0.022179 | 2.943s ± 0.256s |
+| `constriction` | `constriction_c205_canonical` | 60.66% ± 2.30% | 1.246275 ± 0.044657 | 2.521s ± 0.045s |
+| `quantum` | `quantum_beta_0.4_0.9` | 48.58% ± 2.71% | 1.519246 ± 0.052511 | 2.403s ± 0.022s |
+
+
+
+검증 1위였던 `local_best`가 held-out 확인에서도 가장 높은 평균 정확도와 가장 낮은 평균 손실을 기록했습니다. `local_best`와 `inertia`는 동일 30×80 예산에서 Adaptive Moment보다 높은 평균 정확도를 기록했습니다. $n=5$이므로 이 순서의 통계적 유의성이나 다른 워크로드로의 일반화를 주장하지 않습니다.
+
+### 6.4 Adaptive Moment 파티클 스케일링
+
+| 비교 방식 | 파티클 | 세대 | Particle-epochs | Test Accuracy (Mean ± SD) | Test Loss (Mean ± SD) | Fit Time (Mean ± SD) | 30×80 대비 정확도 |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| Fixed epochs | 30 | 80 | 2,400 | 62.12% ± 3.07% | 1.193469 ± 0.086618 | 2.685s ± 0.090s | 기준 |
+| Fixed epochs | 60 | 80 | 4,800 | 65.94% ± 0.87% | 1.074629 ± 0.046106 | 5.586s ± 0.517s | +3.82%p |
+| Fixed epochs | 90 | 80 | 7,200 | 70.32% ± 2.16% | 0.931880 ± 0.038073 | 8.627s ± 0.448s | +8.20%p |
+| Fixed epochs | 120 | 80 | 9,600 | **72.34% ± 1.82%** | **0.902448 ± 0.058380** | 11.174s ± 0.718s | **+10.22%p** |
+| Fixed particle-epochs | 30 | 80 | 2,400 | 62.12% ± 3.07% | 1.193469 ± 0.086618 | 2.685s ± 0.090s | 기준 |
+| Fixed particle-epochs | 60 | 40 | 2,400 | 50.74% ± 2.66% | 1.534634 ± 0.078628 | 2.786s ± 0.095s | -11.38%p |
+| Fixed particle-epochs | 90 | 27 | 2,430 | 47.82% ± 6.31% | 1.610771 ± 0.098843 | 3.109s ± 0.203s | -14.30%p |
+| Fixed particle-epochs | 120 | 20 | 2,400 | 41.06% ± 2.36% | 1.800035 ± 0.072261 | 3.029s ± 0.179s | -21.06%p |
+
+
+
+80세대를 유지한 비교에서는 60, 90, 120개 파티클이 각각 **+3.82%p**, **+8.20%p**, **+10.22%p**였고 각 파티클 수에서 5개 paired seed가 모두 30개 기준보다 높았습니다. 그러나 120개 설정의 평균 fit 시간은 30개 대비 **4.16배**였습니다. 약 2,400 particle-epochs를 고정하면 더 많은 파티클 때문에 세대가 40/27/20으로 줄어 모든 비교에서 정확도가 낮았습니다. 이 결과는 파티클 수 자체의 무비용 효과가 아니라 추가 평가 예산과 충분한 세대 수의 결합 효과를 보여줍니다.
+
+### 6.5 확장 연구 해석 한계
+
+1. Search는 시드 3개, confirmation/scaling은 시드 5개로 제한됩니다. 통계적 유의성 검정이나 보편적 우위를 주장하지 않습니다.
+2. PCA32 선형 MNIST 한 워크로드의 결과이며 전체 MNIST, CNN, 대형 모델로 직접 일반화할 수 없습니다.
+3. validation 평균이 가까운 후보는 시드 수가 늘면 선택 순서가 바뀔 수 있습니다.
+4. 테스트셋은 search에 사용하지 않았지만, 공개된 scaling 비교를 추가적인 테스트셋 기반 하이퍼파라미터 선택으로 사용해서는 안 됩니다.
+5. fixed-epochs 비교는 총 particle-evaluations가 2,400에서 9,600으로 증가하므로 compute-equal 비교가 아닙니다. fixed particle-epochs도 디바이스 벡터화와 세대별 오버헤드까지 동일하게 만들지는 않습니다.
+6. 120×80 replication은 같은 PCA32 데이터와 테스트셋을 다시 평가한 수치 재현성 검증입니다. fresh seed는 스웜 난수에 대해서만 독립적이며, 새로운 표본이나 외부 데이터셋에 대한 독립 검증은 아닙니다.
+
+### 6.6 120p×80e 파티클 스케일링 재현성 검증 (Replication Protocol 1.0.0)
+
+발표된 Adaptive Moment 120-particle × 80-epoch fixed-epoch 결과를 별도 수트([`test/reproduce_scaling.py`](test/reproduce_scaling.py))로 다시 실행했습니다. 데이터 fingerprint `dfe645918ece54c0`, 선택 후보 `am_b0.06_s0.5`, MPS, PyTorch 2.13.0, pso2keras 4.0.0을 baseline과 일치시켰습니다.
+
+사전 선언 합격 조건은 (1) 시드 71~75 exact replay의 시드별 테스트 정확도 최대 절대 차이 $\le 0.005$와 초기 모델 fingerprint 일치, (2) 시드 81~85 fresh-seed 평균 정확도의 baseline 대비 절대 차이 $\le 0.03$, (3) 두 집단 95% t-신뢰구간 중첩입니다.
+
+| 집단 | 시드 | Test Accuracy (Mean ± SD) | 95% t-CI | Baseline 대비 | 판정 |
+| --- | --- | ---: | ---: | ---: | --- |
+| Baseline | 71~75 | 72.34% ± 1.82% | [70.08%, 74.60%] | 기준 | 기준 |
+| Exact replay | 71~75 | 72.34% ± 1.82% | [70.08%, 74.60%] | 시드별 최대 차이 **0.00%p** | **PASS** |
+| Fresh seed | 81~85 | **73.60% ± 1.66%** | [71.54%, 75.66%] | **+1.26%p** | **PASS** |
+
+Exact replay의 초기 모델 fingerprint는 5개 시드 모두 baseline과 일치했습니다. Fresh-seed 평균 차이는 1.26%p로 3%p 허용 범위 안이고 두 95% t-신뢰구간도 중첩되어 전체 판정은 **PASS**입니다. 추가 적합 실행은 10회이며 모두 MPS에서 오류 없이 완료되었습니다.
+
+- **검증 실행 명령**: `uv run --locked --extra examples python test/reproduce_scaling.py --device mps`
+- **출력 아티팩트**: [`benchmark_results/pso_v4_120p80_replication.json`](benchmark_results/pso_v4_120p80_replication.json), [`benchmark_results/pso_v4_120p80_replication.csv`](benchmark_results/pso_v4_120p80_replication.csv)
+
+### 6.7 120p epoch 확장 수렴 진단 (Epoch Convergence Protocol 1.0.0)
+
+`am_b0.06_s0.5`, 파티클 120개, 시드 71~75를 각각 240세대까지 한 번에 연속 실행하고 20세대 간격의 global-best 체크포인트를 같은 테스트셋에서 진단했습니다. Epoch 80의 시드별 정확도는 기존 120×80 baseline과 최대 차이 0.00%p로 일치하여 궤적 prefix가 재현됐습니다.
+
+| Epoch | Particle-epochs | Training Best Loss (Mean ± SD) | Test Accuracy (Mean ± SD) | Test Loss (Mean ± SD) |
+| ---: | ---: | ---: | ---: | ---: |
+| 80 | 9,600 | 0.684245 ± 0.046414 | 72.34% ± 1.82% | 0.902448 ± 0.058380 |
+| 120 | 14,400 | 0.508942 ± 0.026551 | 78.56% ± 0.88% | 0.686080 ± 0.033467 |
+| 160 | 19,200 | 0.426009 ± 0.011667 | 81.58% ± 1.17% | 0.599888 ± 0.027074 |
+| 200 | 24,000 | 0.385320 ± 0.008996 | 82.58% ± 0.64% | 0.555652 ± 0.020276 |
+| 240 | 28,800 | **0.359582 ± 0.009652** | **83.52% ± 1.05%** | **0.515820 ± 0.018827** |
+
+사전 기준은 (1) 80→240 mean training loss 감소율 1% 이상이면 post-80 optimization 지속, (2) mean test accuracy +1%p 이상이면 유의미한 held-out 개선, (3) 200→240 loss 감소율 1% 미만과 정확도 절대 변화 0.5%p 미만을 동시에 만족하면 late plateau로 분류하는 방식입니다.
+
+실측 80→240 training loss 감소율은 **47.30%**, 정확도 증가는 **+11.18%p**였고 5개 시드 모두 정확도가 상승했습니다. 200→240에서도 loss가 **6.68%** 감소하고 정확도가 평균 **+0.94%p** 변했으며 5개 중 4개 시드가 상승했습니다. 각 시드의 마지막 training-best 갱신 epoch는 240/240/240/239/240이었습니다. 따라서 early stagnation, overfitting, late plateau는 모두 false입니다. 다만 구간별 정확도 이득은 80→120 **+6.22%p**, 120→160 **+3.02%p**, 160→200 **+1.00%p**, 200→240 **+0.94%p**로 감소해 한계효용은 줄고 있습니다.
+
+
+
+- **실행 명령**: `uv run --locked --extra examples python test/epoch_convergence.py --device mps`
+- **출력 아티팩트**: [`benchmark_results/pso_v4_epoch_convergence.json`](benchmark_results/pso_v4_epoch_convergence.json), [`benchmark_results/pso_v4_epoch_convergence.csv`](benchmark_results/pso_v4_epoch_convergence.csv)
+- **해석 제한**: 체크포인트 테스트 정확도는 같은 테스트셋을 반복 관찰한 진단값이며, epoch 선택이나 자동 중단에 사용해서는 안 됩니다. 실제 stopping rule은 별도 validation split에 정의해야 합니다.
+
+### 6.8 전체 MNIST 60,000/10,000 학습 (Full MNIST Protocol 1.0.0)
+
+공식 MNIST train 60,000개와 test 10,000개 전체를 사용했습니다. 픽셀 정규화와 flatten 후 PCA32 whitening을 train 60,000개에만 적합했으며 설명 분산 비율 합은 0.743600입니다. 고정된 `am_b0.06_s0.5`를 `evaluation="full"`, `fitness_size=None`, batch 60,000, 파티클 120개, 240 epochs, 시드 71~75로 실행했습니다. 따라서 각 파티클은 매 epoch마다 학습 60,000개 전체에서 평가됐습니다.
+
+| Epoch | Training Best Loss (Mean ± SD) | Full Test Accuracy (Mean ± SD) | Full Test Loss (Mean ± SD) | 2k-fitness study 대비 |
+| ---: | ---: | ---: | ---: | ---: |
+| 80 | 0.768448 ± 0.026961 | 77.67% ± 1.50% | 0.725023 ± 0.033552 | +5.33%p |
+| 120 | 0.589822 ± 0.014141 | 83.28% ± 0.83% | 0.551133 ± 0.018616 | +4.72%p |
+| 160 | 0.511683 ± 0.013526 | 85.56% ± 0.56% | 0.482441 ± 0.012016 | +3.98%p |
+| 200 | 0.465194 ± 0.010498 | 86.85% ± 0.32% | 0.438875 ± 0.008499 | +4.27%p |
+| 240 | **0.436664 ± 0.008101** | **87.70% ± 0.36%** | **0.412078 ± 0.006848** | **+4.18%p** |
+
+80→240에서 training best loss는 **43.18%** 감소하고 테스트 정확도는 **+10.03%p** 상승했습니다. 200→240에서도 loss가 **6.13%** 감소하고 정확도가 **+0.85%p** 상승했으며 모든 시드가 개선됐습니다. 5개 시드 모두 마지막 training-best가 epoch 240에서 갱신되어 full-data 조건에서도 late plateau는 false입니다.
+
+이 프로토콜은 5개 시드 합계 144,000 particle-epochs와 8,640,000,000 particle-sample evaluations를 수행했습니다. 계측된 `fit()` 합계는 165.856초입니다. Full-data 정확도는 공통 checkpoint마다 2k-fitness 연구보다 3.98~5.33%p 높았지만, PCA 적합 범위, fitness objective, evaluation plugin의 RNG 소비가 함께 바뀌므로 정확도 차이는 기술적 비교이며 인과 추정이 아닙니다. 서로 다른 학습 objective의 training loss 절댓값도 직접 비교하지 않습니다.
+
+
+
+- **실행 명령**: `uv run --locked --extra examples python test/full_mnist_study.py --device mps`
+- **출력 아티팩트**: [`benchmark_results/pso_v4_full_mnist.json`](benchmark_results/pso_v4_full_mnist.json), [`benchmark_results/pso_v4_full_mnist.csv`](benchmark_results/pso_v4_full_mnist.csv)
+- **해석 제한**: 공식 split 전체를 사용했지만 입력은 PCA32이고 모델은 `Linear(32,10)`입니다. 원본 784차원 PSO나 CNN 결과가 아닙니다. 반복 test checkpoint는 사후 진단일 뿐 stopping rule 선택에 사용하지 않습니다.
+
+### 6.9 원본 MNIST 딥 신경망 아키텍처 및 최적화기 비교 (Deep Accuracy Protocol 1.0.0)
+
+PCA 차원 축소 없이 공식 MNIST 데이터셋 전체(학습 60,000개, 테스트 10,000개) 원본 $1 \times 28 \times 28$ 입력을 대상으로 딥 신경망 아키텍처 및 최적화기 특성을 다중 트랙으로 평가했습니다 (`Deep Accuracy Protocol 1.0.0`, $n=3$, seeds 101~103). 픽셀 정규화 mean(`0.13066`)과 std(`0.308108`)는 학습 60,000개에서만 산출하여 평가 데이터 누수를 차단했습니다. 테스트 10,000개는 히스토리 모니터링 전용으로 사용되었으며, 테스트 성능에 기반한 하이퍼파라미터 선택이나 조기 종료(stopping rule)는 수행하지 않았습니다.
+
+실험 조건: Apple Silicon MPS, PyTorch 2.13.0, batch size 256, lr 0.001. Adam 실행은 10 epochs, PSO 실행은 파티클 30개 × 40세대에 2,000개 고정 서브셋(`fitness_size=2000`) 평가 및 선택된 Adaptive Moment 후보 설정(`am_b0.06_s0.5`, `c0=c1=1.49618`, `w=0.7298`, `velocity_limit_ratio=0.025`, `mutation_swarm=0.02`, `moment_step_size=0.5`)을 적용했습니다. 하이브리드(PSO→Adam) 방식은 PSO 40세대 탐색 후 Adam 10세대를 수행하므로 pure Adam 대비 추가 PSO 계산량을 포함하는 비동등 계산량 설정입니다.
+
+#### 트랙 1: 아키텍처 레인 성과 (Adam 10 Epochs, Mean ± Sample SD, $n=3$)
+
+| 아키텍처 (`arch`) | 모델 구조 및 파라미터 수 | 테스트 정확도 (Mean ± SD) | 테스트 손실 (Mean ± SD) | 98% 정확도 도달 속도 |
+| --- | --- | ---: | ---: | --- |
+| `raw_linear` | `Linear(784, 10)` (7,850 params) | 92.45% ± 0.10% | 0.268945 ± 0.002050 | 미도달 |
+| `raw_mlp` | `Linear(784,128) - ReLU - Linear(128,64) - ReLU - Linear(64,10)` (109,386 params) | 97.70% ± 0.08% | 0.078368 ± 0.002818 | 미도달 |
+| `compact_cnn` | `Conv2d(1,8,3) - ReLU - MaxPool2d - Conv2d(8,16,3) - ReLU - MaxPool2d - Linear(784,10)` (9,098 params) | **98.53% ± 0.16%** | **0.043809 ± 0.004907** | **5 Epoch 이내 전 시드 달성** |
+
+`compact_cnn` 아키텍처의 경우 시드 101(4 epoch), 시드 102(3 epoch), 시드 103(5 epoch)에서 모두 5 epoch 이내에 테스트 정확도 98% 이상을 달성했습니다.
+
+#### 트랙 2: 최적화기 레인 성과 (Compact CNN 9,098 Params, Mean ± Sample SD, $n=3$)
+
+| 최적화 기법 (`optimizer`) | 실행 구성 | 테스트 정확도 (Mean ± SD) | 테스트 손실 (Mean ± SD) | 판정 및 특성 |
+| --- | --- | ---: | ---: | --- |
+| `adam_only` | Adam 10 epochs | **98.53% ± 0.16%** | **0.043809 ± 0.004907** | 역전파 경사하강법 기반 최적화 |
+| `pso_only` | PSO 40 epochs (30p × 40e) | 36.76% ± 3.76% | 14.104417 ± 8.075411 | 고차원 전가중치 수렴 실패 |
+| `hybrid` (PSO→Adam) | PSO 40e + Adam 10e | 97.30% ± 0.75% | 0.086542 ± 0.023969 | 추가 탐색 연산에도 pure Adam 대비 저조 |
+
+
+
+- **실행 명령**: `uv run --locked --extra examples python test/deep_accuracy_study.py --device mps`
+- **출력 아티팩트**: [`benchmark_results/pso_v4_deep_accuracy.json`](benchmark_results/pso_v4_deep_accuracy.json), [`benchmark_results/pso_v4_deep_accuracy.csv`](benchmark_results/pso_v4_deep_accuracy.csv)
+- **결과 해석 및 한계점**:
+ 1. **아키텍처 인덕티브 바이어스**: Adam 조건을 고정한 아키텍처 레인에서 Compact CNN은 MLP보다 약 1/12의 파라미터로 정확도가 0.83%p 높았습니다. 원본 이미지의 공간적 구조를 사용하는 것이 측정된 차이에 중요했습니다.
+ 2. **고차원 전가중치 PSO의 한계**: 이 프로토콜의 30p × 40e·fixed-2k 예산에서 9,098개 CNN 파라미터를 직접 탐색한 PSO는 36.76% ± 3.76%였습니다. 이 결과는 해당 설정에서 역전파를 대체하지 못했음을 보이지만, 더 큰 예산이나 다른 간접 인코딩을 포함한 PSO의 이론적 한계를 증명하지는 않습니다.
+ 3. **하이브리드 초기화 결과**: PSO→Adam은 97.30% ± 0.75%로 동일한 10-epoch pure Adam의 98.53% ± 0.16%보다 낮았습니다. 추가 PSO 계산량도 포함되므로 측정한 초기화 방식의 실용적 이점은 관측되지 않았습니다.
+ 4. **표본 및 적용 범위 한계**: 본 실험은 $n=3$ 기술적(descriptive) 표본 측정 결과이며 통계적 유의성이나 일반적 보편 우위로 확언하지 않습니다.
+
+
+### 6.10 희소 부호 해시 부분공간·단계적 평가·스웜 앙상블 탐색 (MNIST-PSO-RAW-V5 1.0.0)
+
+공식 MNIST 데이터셋(학습 60,000개, 테스트 10,000개) 원본 $1 \times 28 \times 28$ 입력을 대상으로 Compact CNN 아키텍처(9,098개 파라미터)의 고정 희소 부호 해시 부분공간, 단계적 표본 확장 평가, 검증 다양성 기반 스웜 앙상블 탐색을 수행했습니다 (`MNIST-PSO-RAW-V5 1.0.0`).
+
+학습 데이터 60,000개는 탐색 전용 학습 세트 50,000개와 검증 세트 10,000개로 분할되었으며 (`split_seed=20260902`, `split_fingerprint=51b289d9f503a9f3`), 픽셀 정규화 평균(`0.130682`) 및 표준편차(`0.308127`)는 50,000개 탐색 학습 세트에서만 산출하여 데이터 누수를 차단했습니다. 부분공간 차원과 최종 단일 모델·앙상블 구성은 검증 세트에서 선택했으며, 테스트 세트 10,000개는 선택 완료 후 단일 모델과 앙상블의 최종 엔드포인트에만 사용했습니다.
+
+#### 트랙 1: 부분공간 차원 탐색 파일럿 (Pilot Subspace Search, 30p × 160e, fixed-2k subset)
+
+파티클 30개 × 160세대 고정 2,000개 서브셋 조건에서 결정론적 희소 부호 해시 부분공간(290, 1024, 4096차원)과 전가중치(9,098차원) 탐색 성능을 비교했습니다 (`pilot_seed=91`). 손실 함수는 Cross-Entropy Loss를 주 목적(primary)으로 하고 Accuracy를 동률 처리(tiebreak) 지표로 사용했습니다.
+
+| 부분공간 차원 (`dimension`) | 검증 정확도 (%) | 검증 손실 (CE Loss) | 쿼리 수 (Queries) | 샘플 평가 수 (Sample Evals) | 계산 시간 (Wall Time) |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| `290` | 22.33% | 2.216933 | 4,800 | 9,600,000 | 6.0698s |
+| `1024` | 41.34% | 1.960143 | 4,800 | 9,600,000 | 6.0666s |
+| `4096` | 55.97% | 1.550738 | 4,800 | 9,600,000 | 6.2638s |
+| `full` (9,098-D) | **67.18%** | **1.205564** | 4,800 | 9,600,000 | 6.1629s |
+
+파일럿 예산에서는 전가중치 9,098차원 탐색의 검증 정확도(67.18%)가 가장 높고 손실(1.205564)이 가장 낮아, 확인 프로토콜의 차원으로 선택했습니다.
+
+#### 트랙 2: 단계적 표본 확장 확인 프로토콜 (Confirmation Protocol, 60p × 600e, $n=3$)
+
+파티클 60개 × 600세대 설정으로 3개 무작위 시드(101, 102, 103)에 대해 단계적 표본 확장 스케줄(`2000:420,10000:135,50000:45`)을 적용했습니다. Epoch 1~420은 2,000개 서브셋, 421~555는 10,000개 서브셋, 556~600은 50,000개 전체 탐색 세트로 계층적 평가를 진행했습니다. Epoch 421 및 556의 새 목적함수 평가 전에 모든 파티클의 pbest 적합도를 새 서브셋으로 전수 재평가한 후 gbest를 재구성하여 서로 다른 목적함수의 과거 점수를 직접 비교하지 않았습니다.
+
+- **확인 실행 검증 요약** ($n=3$, seeds 101~103):
+ - Validation Best-pbest Accuracy (Mean ± SD): **82.34% ± 0.35%** (std: 0.346987%, 95% t-CI: ±0.861973%)
+ - Validation Best-pbest NLL (Mean ± SD): **0.592376 ± 0.018705** (95% t-CI: ±0.046467)
+
+#### 트랙 3: 최종 엔드포인트 및 스웜 앙상블 성과 (Final Endpoint & Swarm Ensemble)
+
+검증 세트 성능에 따라 선택된 단일 최적 모델(Seed 103, Particle 54)과 검증 다양성 기준 상위 Top-5 파티클로 구성된 스웜 앙상블(Top-5 distinct pbest models across seeds: 103/P54, 102/P50, 101/P48, 102/P29, 101/P22)의 최종 공식 Held-out 테스트(10,000개) 성과 비교입니다.
+
+| 엔드포인트 구분 (`endpoint`) | 모델 구성 및 선택 기준 | 검증 정확도 | 검증 NLL | 테스트 정확도 | 테스트 NLL | 테스트 Brier | 테스트 ECE | 상호 불일치도 (Disagreement) |
+| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| **단일 최적 모델** (`single_model`) | Validation NLL 최저 (Seed 103, P54) | 82.64% | 0.571431 | 83.23% | 0.556332 | 0.253921 | 0.085242 | - |
+| **스웜 앙상블 (Top-5)** (`ensemble`) | Validation 다양성 Top-5 pbest | 86.60% | 0.548785 | **87.00%** | **0.535928** | **0.236233** | 0.164284 | 0.1585 |
+| **앙상블 대비 단일 차이** ($\Delta$) | Ensemble - Single | +3.96%p | -0.022646 | **+3.77%p** | **-0.020404** | **-0.017688** | **+0.079042** | - |
+
+#### 자원 사용량 계측 (Resource Accounting)
+
+- **총 후보 목적함수 평가 쿼리 수**: 127,560 회 (파일럿 19,200 + 확인 108,360)
+- **총 샘플 수준 평가 수**: 848,400,000 회 (848.4M)
+- **합산 최적화 벽시계 시간**: 473.4657 초 (파일럿 24.5631초 + 확인 448.9026초)
+
+
+
+- **실행 명령**: `uv run --locked --extra examples python test/deep_pso_methods.py --device mps`
+- **출력 아티팩트**: [`benchmark_results/pso_v5_deep_methods.json`](benchmark_results/pso_v5_deep_methods.json), [`benchmark_results/pso_v5_deep_methods.csv`](benchmark_results/pso_v5_deep_methods.csv)
+- **결과 해석 및 특성**:
+ 1. **파일럿 차원 비교**: 290~4096차원 희소 부호 해시 부분공간은 동일한 30p × 160e 파일럿 예산에서 전가중치(9,098차원)보다 검증 정확도가 낮고 NLL이 높았습니다. 다른 투영, 차원, 예산의 결과까지 일반화하지 않습니다.
+ 2. **단계적 표본 전환과 회복**: 2k→10k→50k 전환 시 새 목적함수에서 pbest를 재평가하자 손실이 일시 상승하고 정확도가 하락했으며, 이후 각 단계에서 다시 개선됐습니다. 이 점프는 서로 다른 표본 목적함수의 난이도 차이를 반영하며 동일 궤적 손실의 악화로 해석하지 않습니다.
+ 3. **최종 단일 모델 수렴 한계**: 60p × 600e 단계적 탐색의 단일 모델 테스트 정확도는 83.23%였습니다. 보존된 v4 30p × 40e accuracy-primary PSO의 36.76%보다 높지만 목적함수·데이터 분리·예산이 모두 달라 인과적 개선량으로 해석할 수 없습니다. v4 Adam 10-epoch 평균 98.53%와도 계산 방식·예산이 비동등하며, 측정 정확도는 여전히 15.30%p 낮았습니다.
+ 4. **앙상블 다양성 및 확률 보정(ECE) 트레이드오프**: 검증 다양성으로 선택한 Top-5 앙상블은 단일 모델보다 테스트 정확도가 3.77%p 높고 NLL/Brier가 낮았지만 ECE는 0.079042 높았습니다(0.085242 → 0.164284). 이 실행은 예측 불일치가 활용 가능한 앙상블 이득과 함께 나타날 수 있음을 보였지만, 높은 손실이나 다양성만으로 일반화·보정 향상을 판정할 수는 없습니다.
+ 5. **종료 시점의 수렴 상태**: 50k 최종 단계에서 세 시드 모두 기록된 최저 학습 손실이 마지막 Epoch 600에 갱신됐습니다. 따라서 600세대 결과를 수렴 한계로 해석할 수 없으며, 더 긴 50k 단계의 효용은 별도 validation 기반 중단 규칙으로 확인해야 합니다.
+
+### 6.11 V5 탐색 구조 회귀 원인 분리 (MNIST-PSO-RAW-V6 1.0.0)
+
+V5의 83.23% 단일 모델 결과가 고차원 자체의 한계인지, 탐색 구조 변경에 따른 회귀인지 분리하기 위해 Phase A/B 진단을 수행했습니다. 공식 MNIST test split은 로드하지 않았고, train 60,000개만 `split_seed=20260902`로 search 50,000개와 validation 10,000개로 분할했습니다. 모든 비교는 동일한 결정론적 2,000개 search subset, Compact CNN 초기 모델 seed 41, CE loss-primary/accuracy-tiebreak 선택을 사용했습니다.
+
+#### 단일시드 구조 screen (seed 91, 30p × 160e)
+
+| ID | 핵심 변경 | Validation Accuracy | Validation NLL |
+| --- | --- | ---: | ---: |
+| G8 | 기존 `Optimizer` 의미론 제어군 | **70.99%** | **0.883557** |
+| G5 | per-tensor SD + velocity + mutation + bound ±6 | 70.93% | 0.901510 |
+| G6 | G5 + initial radius 1.5 | 69.56% | 0.961290 |
+| G4 | per-tensor SD + velocity + mutation + bound ±3 | 65.76% | 1.116280 |
+| G3 | G0 + mutation 0.02 | 68.07% | 1.130839 |
+| G0 | V5 구조 제어군 | 67.73% | 1.183117 |
+| G7 | G2 + independent positions | 58.79% | 1.291266 |
+| G2 | G0 + initial velocity | 60.72% | 1.296105 |
+| G1 | global RMS coordinate scale | 62.32% | 1.437604 |
+
+한 시드에서 G3 mutation은 G0 대비 NLL을 0.052278 낮췄고, G5의 ±6 경계는 G4 대비 정확도를 5.17%p 높이고 NLL을 0.214770 낮췄습니다. 반면 초기 속도만 추가한 G2와 global RMS scale G1은 G0보다 낮았습니다. 이 screen은 확인 대상 선택용이며 단일시드 차이를 일반적 인과 효과로 확정하지 않습니다.
+
+#### 3-시드 확인 (seeds 101–103, 60p × 420e)
+
+| ID | Validation Accuracy (Mean ± Sample SD) | Validation NLL (Mean ± Sample SD) | G8 대비 Accuracy | G8 대비 NLL |
+| --- | ---: | ---: | ---: | ---: |
+| G8 | **84.92% ± 0.99%** | **0.481440 ± 0.029447** | 기준 | 기준 |
+| G6 | 84.25% ± 0.22% | 0.503809 ± 0.015789 | -0.67%p | +0.022369 |
+| G5 | 84.24% ± 0.90% | 0.510297 ± 0.024899 | -0.68%p | +0.028857 |
+| G0 | 79.53% ± 0.58% | 0.689687 ± 0.008079 | -5.39%p | +0.208247 |
+| G1 | 76.95% ± 2.49% | 0.833759 ± 0.123667 | -7.96%p | +0.352319 |
+
+G5와 G6은 사전 선언한 회복 기준(G8 대비 accuracy 1.0%p 이내, NLL 0.05 이내)을 모두 통과했습니다. 따라서 V5 G0의 격차는 9,098차원 자체만으로 설명되지 않으며, 제거했던 탐색 다양성과 좁은 normalized 경계의 묶음이 주요 원인입니다. G6은 사전 순위 규칙인 validation NLL 오름차순에서 G5보다 0.006488 낮아 다음 단계 기준으로 선택됐지만, 차이는 회복 기준보다 작습니다.
+
+개별 요인 판정은 제한적입니다. G1은 G0보다 정확도가 2.57%p 낮고 NLL이 0.144072 높아 per-tensor SD scaling을 global RMS로 교체하는 가설은 기각됐습니다. G5/G6의 회복은 확인됐지만 G2–G4를 3개 시드로 확인하지 않았으므로 초기 속도, mutation, mutation 상호작용, 경계 확장의 독립 효과는 아직 unresolved입니다. G6과 G5 차이는 accuracy +0.01%p/NLL -0.006488로 넓은 초기 반경의 material improvement 기준을 충족하지 못했습니다.
+
+#### 자원·누수 계측 및 다음 단계
+
+- 후보 목적함수 쿼리: **421,200**
+- 후보 샘플 평가: **842,400,000**
+- 합산 최적화 시간: **596.9980초**
+- 합산 validation 평가 시간: **9.1062초**
+- 공식 test 데이터 로드 및 평가: **0회**
+
+
+
+- **실행 명령**: `uv run --locked --extra examples python test/deep_pso_v6.py --phase all --device mps`
+- **출력 아티팩트**: [`benchmark_results/pso_v6_phase_b.json`](benchmark_results/pso_v6_phase_b.json), [`benchmark_results/pso_v6_phase_b.csv`](benchmark_results/pso_v6_phase_b.csv)
+- **다음 단계**: G6 구조를 기준으로 `sqrt(9098/d)` 반경·속도·경계 보정을 적용한 공정한 subspace 비교(Phase C)를 수행합니다. 이후에만 objective schedule과 transition moment reset을 분리합니다. CCPSO/CSO는 whole-vector validation 성능이 90% 미만에서 plateau일 때까지 보류합니다.
+
+### 6.12 더 무거운 태스크의 전가중치 PSO 실행 가능성 (HEAVY-TASK-PSO-V6 1.0.0)
+
+동일한 보존 기법 G0/G5/G6/G8을 더 큰 모델 및 다른 영상 분류 데이터에 적용했습니다. MNIST와 FashionMNIST 모두 공식 train split만 로드한 뒤 `split_seed=20260902`로 search 50,000/validation 10,000을 층화 분할하고, search 50,000개에서만 정규화 통계를 적합했습니다. 모델 축은 Compact CNN 9,098개와 Conv16→32·FC32 구조의 WideCNN 55,338개 파라미터입니다. 공식 test split 로드와 평가는 모두 0회입니다.
+
+단일시드 screen은 네 workload와 G0/G5/G6/G8의 16개 셀을 12 particles × 40 epochs·fixed-2k로 평가했습니다. Validation NLL 우선, accuracy 동률 판정으로 선택된 normalized 방법은 MNIST Compact/Fashion Compact에서 G6, MNIST Wide/Fashion Wide에서 G5였습니다. 이 선택은 같은 validation split을 사용했으므로 독립적인 일반화 추정치가 아니라 확인 대상 축소 절차입니다.
+
+3-시드 확인은 workload마다 G8과 선택된 normalized 방법을 12 particles × 80 epochs·fixed-10k로 실행했습니다.
+
+| Workload | Method | Validation Accuracy (Mean ± Sample SD) | Validation NLL (Mean ± Sample SD) | 초기 모델 대비 Accuracy | NLL 감소율 | 사전 최적화 기준 |
+| --- | --- | ---: | ---: | ---: | ---: | --- |
+| MNIST Compact (9,098) | G8 | **49.15% ± 1.32%** | **1.518089 ± 0.061523** | +42.50%p | 34.71% | 통과 |
+| MNIST Compact (9,098) | G6 | 45.97% ± 3.55% | 1.642081 ± 0.091398 | +39.32%p | 29.38% | 통과 |
+| MNIST Wide (55,338) | G8 | 41.03% ± 4.06% | 1.733351 ± 0.084331 | +31.72%p | 25.43% | 통과 |
+| MNIST Wide (55,338) | G5 | **43.86% ± 3.51%** | **1.721259 ± 0.098656** | +34.55%p | 25.95% | 통과 |
+| Fashion Compact (9,098) | G8 | **47.00% ± 5.23%** | **1.511217 ± 0.168628** | +38.92%p | 34.87% | 통과 |
+| Fashion Compact (9,098) | G6 | 45.62% ± 3.59% | 1.584443 ± 0.053077 | +37.54%p | 31.71% | 통과 |
+| Fashion Wide (55,338) | G8 | 41.67% ± 2.27% | 1.615937 ± 0.036692 | +32.90%p | 30.08% | 통과 |
+| Fashion Wide (55,338) | G5 | **46.31% ± 7.57%** | **1.525747 ± 0.149706** | +37.54%p | 33.99% | 통과 |
+
+모든 실행은 수치적으로 finite했고 사전 feasibility 기준을 통과했으므로, 약 55k 파라미터 및 FashionMNIST 범위에서도 이 PSO 기법들이 목적함수를 낮추고 초기 정확도를 높이는 것은 확인됐습니다. 다만 최고 평균 정확도가 49.15%에 불과해 유용한 분류기 학습이나 수렴 완료는 확인되지 않았습니다. 80 epochs의 endpoint만 비교했고 plateau 판정용 궤적을 보존하지 않았으므로, 이 프로토콜은 수렴 한계나 추가 세대의 효용을 결정하지 않습니다.
+
+모델 파라미터가 6.08배 증가하면서 12-particle core swarm state는 custom 방법 기준 약 2.08 MiB에서 12.67 MiB, G8 기준 약 2.12 MiB에서 12.88 MiB로 선형 증가했습니다. 확인 실행 처리량은 Compact CNN의 약 1.90~2.19M samples/s에서 WideCNN의 약 0.98~1.04M samples/s로 감소했습니다. G8의 Wide 모델은 Compact 모델보다 MNIST에서 정확도가 8.12%p, FashionMNIST에서 5.34%p 낮았습니다. 반면 screen-selected G5는 두 Wide workload에서 G8 평균을 앞섰지만, 방법 선택에 사용한 validation 재사용과 $n=3$의 큰 변동성(Fashion Wide G5 SD 7.57%p) 때문에 고차원 우월성으로 일반화하지 않습니다.
+
+- 후보 목적함수 쿼리: **30,720**
+- 후보 샘플 평가: **245,760,000**
+- 합산 최적화 시간: **188.7283초**
+- 합산 validation 평가 시간: **6.3826초**
+- 공식 test 데이터 로드 및 평가: **0회**
+
+
+
+- **실행 명령**: `uv run --no-sync python test/heavy_task_feasibility.py --stage screen --device mps --out-dir /tmp/pso-v6-heavy-screen` 이후 `uv run --no-sync python test/heavy_task_feasibility.py --stage confirm --device mps --screen-artifact /tmp/pso-v6-heavy-screen/pso_v6_heavy_tasks_screen.json`
+- **출력 아티팩트**: [`benchmark_results/pso_v6_heavy_tasks.json`](benchmark_results/pso_v6_heavy_tasks.json), [`benchmark_results/pso_v6_heavy_tasks.csv`](benchmark_results/pso_v6_heavy_tasks.csv)
+- **판정**: 더 무거운 measured workload에서도 PSO 실행과 제한적 최적화는 가능하지만, 현재 예산의 전가중치 탐색은 실용적인 학습기로 판정하지 않습니다.
+
+### 6.13 고정 부분공간 PSO의 품질·상태 Pareto 반복 연구 (HEAVY-PSO-AUTORESEARCH 1.0.0)
+
+6.12의 네 workload를 대상으로 방법 제안 → 고정 평가 → 분석 → 유지/기각을 반복했습니다. 공식 test split은 끝까지 로드하지 않았고, primary evaluator는 12 particles × 80 epochs × fixed-10k, seeds 101~103, workload별 validation accuracy/NLL, 그리고 persistent core swarm state를 고정했습니다. 후보는 모든 workload에서 baseline state의 50% 이하, accuracy 하락 1%p 이하, NLL 악화 5% 이하를 만족하고, 가장 약한 baseline인 MNIST Wide에서 accuracy 2%p 또는 NLL 5% 이상을 개선해야 통과합니다. 점수는 평균 상대 NLL 개선율 + 평균 accuracy 개선(%p) + 상태 절감 보너스에서 실패 gate당 100점을 차감합니다.
+
+#### 반복 결과와 유지 정책
+
+초기 전역 signed-hash 부분공간은 swarm seed마다 projection도 함께 바꾸어 optimizer 변동과 표현 변동을 혼합했습니다. 별도 projection replica에서 이 문제가 확인됐고, tensor-local 비례 hash는 모든 품질 gate를 크게 악화시켜 기각했습니다. 이후 하나의 전역 projection을 swarm seed 전체에서 고정했습니다. 세 workload에는 ratio 0.5 고정 projection을 사용하고, MNIST Wide에는 기존 단일 실행에서 발견된 projection 592157828을 세 matched seed에서 다시 확인한 뒤 사용했습니다. 반경/속도/경계 multiplier 0.75와 0.5는 MNIST Wide 성능을 각각 41.71%와 36.78%로 낮춰 기각했으며 multiplier 1.0을 유지했습니다.
+
+| Workload | Latent 구성 | State ratio | Baseline Acc / NLL | Development 101~103 Acc / NLL | Confirmation 111~113 Acc / NLL |
+| --- | --- | ---: | ---: | ---: | ---: |
+| MNIST Compact | fixed global, ratio 0.5, projection 1800044939 | 0.4918 | 49.1533% / 1.518089 | 49.0533% / 1.525704 | 48.4667% / 1.550212 |
+| MNIST Wide | fixed global, ratio 0.5, projection 592157828 | 0.5000 | 43.8600% / 1.721259 | 48.3467% / 1.677712 | 45.7233% / 1.734905 |
+| Fashion Compact | fixed global, ratio 0.5, projection 1363313651 | 0.4918 | 47.0033% / 1.511217 | 50.7967% / 1.385324 | 53.1967% / 1.328168 |
+| Fashion Wide | fixed global, ratio 0.5, projection 189641451 | 0.5000 | 46.3100% / 1.525747 | 48.2633% / 1.531421 | 49.4767% / 1.513876 |
+
+Development 정책 `fixed_global_hybrid_v3`는 모든 고정 gate를 통과했습니다. Score는 **15.030089**, 평균 accuracy 개선은 **+2.5333%p**, 평균 상대 NLL 개선은 **2.4968%**, 최대 state ratio는 **0.5**였습니다. 그러나 정책을 재선택하지 않고 swarm seeds 111~113에서 실행한 confirmation은 **한 gate만 실패**했습니다. 모든 workload의 accuracy/NLL 비열화 gate와 state/safety/accounting gate는 통과했지만 MNIST Wide 개선이 **+1.8633%p**로 사전 기준 +2%p에 0.1367%p 미달했습니다. 따라서 독립 확인된 Pareto 승리로 판정하지 않습니다.
+
+두 seed 집합을 합친 6-seed 수치는 사후 기술 통계일 뿐 gate 판정값이 아닙니다. MNIST Compact/MNIST Wide/Fashion Compact/Fashion Wide accuracy 변화는 각각 **-0.3933/+3.1750/+4.9933/+2.5600%p**, 상대 NLL 변화는 **-1.3088/+0.8686/+10.2216/+0.2031%**였습니다. 이 결과는 고정 projection이 projection-coupled 정책보다 해석 가능하고 평균 품질·상태 Pareto를 개선할 가능성을 보이지만, 새 validation split이나 공식 test 일반화 증거는 아닙니다.
+
+- 총 실제 실행: **312 runs**
+- 총 목적함수 쿼리: **299,520**
+- 총 샘플 평가: **2,995,200,000**
+- 실행 wall time 합: **2,264.4978초**
+- 공식 test 데이터 로드 및 평가: **0회**
+- 실행기/평가기: [`test/heavy_pso_autoresearch.py`](test/heavy_pso_autoresearch.py), [`test/evaluate_heavy_autoresearch.py`](test/evaluate_heavy_autoresearch.py)
+- 요약 아티팩트: [`benchmark_results/pso_v6_heavy_autoresearch.json`](benchmark_results/pso_v6_heavy_autoresearch.json), [`benchmark_results/pso_v6_heavy_autoresearch.csv`](benchmark_results/pso_v6_heavy_autoresearch.csv)
+- 전체 반복 결정 로그: [`.omc/autoresearch/heavy-pso-progressive-improvement/runs/20260902T153426Z/decision-log.md`](.omc/autoresearch/heavy-pso-progressive-improvement/runs/20260902T153426Z/decision-log.md)
+
+- **※ 주의 (후속 검증 결과)**: 후속 교차 분할 평가([`REPORT.md` §6.14](#614-heavy-pso-교차-분할-강건성-검증-heavy-pso-cross-split-100))에서 동일 정책이 개발 분할 평가 게이트를 통과하지 못했습니다. 따라서 본 절의 단일 개발 분할 수치는 새 validation split에 대한 강건성 증거가 아닙니다.
+
+
+### 6.14 Heavy PSO 교차 분할 강건성 검증 (HEAVY-PSO-CROSS-SPLIT 1.0.0)
+
+§6.13의 고정 부분공간 수축 정책(`fixed_global_hybrid_v3`)이 단일 개발 분할(split 20260902) 이외의 validation 분할에서도 결과를 재현하는지 확인하기 위해, 개발 분할 20260905/20260906과 시드 101~103에서 매칭 baseline을 다시 실행했습니다. 예산은 12 particles × 80 epochs × fixed-10k로 고정했습니다 (`HEAVY-PSO-CROSS-SPLIT 1.0.0`).
+
+#### 6.14.1 실험 설계 및 개념적 구분
+
+1. **결정 탐색(Decision Iterations) vs 개발 변형(Development Variants)**:
+ - 총 8회 결정 탐색(Decision Iterations 1~8)을 통해 다양한 부분공간 하이퍼파라미터 및 해시 프로젝션을 탐색했습니다.
+ - Iteration 3에서 projection seed replica 1과 replica 2를 별도 평가했으므로, 8회 결정에서 총 9개 개발 변형(Development Variants)을 평가했습니다.
+2. **개발 단계(Development Phase) vs 확인 단계(Confirmation Phase)**:
+ - **개발 단계**: 2개 무작위 개발 분할(20260905, 20260906) 및 시드 101~103 (변형당 8개 셀, 48개 실행)을 기반으로 엄격한 품질/회귀 게이트를 적용했습니다.
+ - **확인 단계**: 개발 단계의 모든 게이트를 통과한 보존 후보에 한해 세 번째 확인 분할(20260907) 및 시드 111~113에서 독립 확인 평가를 수행하도록 정의했습니다.
+3. **검증 분할(Validation Split) vs 공식 테스트(Official Test Split)**:
+ - 학습 50,000개 / 검증 10,000개 층화 분할(Search/Validation)을 사용했으며, 데이터 정규화 통계는 Search 50,000개에서만 산출했습니다.
+ - 공식 테스트 데이터셋(10,000개)은 0회 로드 및 0회 평가로 미사용 완전히 봉인 유지되었습니다 (`official_test_data_loaded = false`, `official_test_evaluations = 0`).
+4. **관측 최상위 후보(Best Observed Candidate) vs 최종 보존 정책(Retained Policy)**:
+ - 평가된 9개 개발 변형 중 탐색 스코어가 가장 높은 후보(Best Observed Candidate)와 모든 게이트를 통과하여 채택되는 최종 보존 정책(Retained Policy)을 명확히 구분했습니다.
+
+#### 6.14.2 주요 결과 및 게이트 평가
+
+1. **동결 정책 (`fixed_global_hybrid_v3`, Iteration 1)**:
+ - §6.13에서 수립된 고정 global projection 및 latent ratio 0.5 정책을 동결하여 교차 평가한 결과, 전체 평균 accuracy 개선은 **+0.1533%p**, NLL 감소는 **0.5546%**에 그쳤습니다.
+ - Accuracy·NLL·MNIST Wide 개선의 3개 development 품질 gate를 위반하여 **FAIL**로 판정했습니다. 개발 gate가 닫혔으므로 confirmation gate는 의도대로 실행하지 않았습니다.
+2. **관측 최상위 후보 (Iteration 5, Largest-Tensor Hash)**:
+ - 8회 결정 탐색 중 최고 스코어(**-185.610686**)를 기록한 Iteration 5(텐서 크기순 비례 해시)는 overall accuracy 개선 **+0.4400%p**, NLL 감소 **3.9493%**, 최악 accuracy 회귀 **-3.0667%p**를 기록했습니다.
+ - 그러나 가장 민감한 게이트인 MNIST Wide accuracy에서 **-2.6633%p** (NLL **2.1874%** 악화)로 여전히 회귀가 관측되어 게이트 미달로 **FAIL** 판정되었습니다.
+3. **확인 단계 과학적 보류 및 보존 실패**:
+ - 9개 개발 변형 전체가 개발 단계 하드 게이트를 통과하지 못함에 따라, 사전 선언된 과학적 엄격성 규칙에 의거하여 확인 분할(20260907) 평가 실행은 **완전히 보류(withheld, confirmation_executed = false)**되었습니다.
+ - 최종 보존 정책은 `retained_policy = null`로 확정되었으며, 공식 test split 역시 0회 평가로 미사용 봉인 상태를 유지했습니다.
+
+#### 6.14.3 실험 및 성과 요약 표
+
+| 항목 (Category) | 세부 사양 및 평가 수치 (Details & Metrics) |
+| --- | --- |
+| **프로토콜 명칭** | `HEAVY-PSO-CROSS-SPLIT 1.0.0` (Publish Protocol: `1.0.0`) |
+| **평가 대상 모델/데이터** | MNIST Compact (9,098), MNIST Wide (55,338), Fashion Compact (9,098), Fashion Wide (55,338) |
+| **스웜/평가 하이퍼파라미터** | 12 particles × 80 epochs × fixed-10k subset, seeds 101~103, matched baseline 재실행 |
+| **데이터 분할 구성** | 개발 분할 2개 (20260905, 20260906) / 확인 분할 1개 (20260907, 실행 보류) |
+| **공식 테스트 데이터** | 0회 로드, 0회 평가 (완전 봉인 유지) |
+| **결정 탐색 및 개발 변형** | 8회 결정 탐색 (Decision Iterations 1~8) / 9개 개발 변형 (Development Variants, Iter 3 Replica 1/2) |
+| **동결 정책 (Iter 1) 결과** | Overall Acc **+0.1533%p**, NLL 감소 **0.5546%**, Worst Acc 회귀 **-7.1767%p**, Worst NLL 회귀 **+14.5682%**, MNIST Wide Acc **-0.3617%p** (FAIL) |
+| **관측 최상위 (Iter 5) 결과** | Score **-185.610686**, Overall Acc **+0.4400%p**, NLL 감소 **3.9493%**, Worst Acc 회귀 **-3.0667%p**, MNIST Wide Acc **-2.6633%p** (FAIL) |
+| **최종 판정 및 보존 정책** | **FAIL** (`retained_policy = null`), 확인 단계 보류 (`confirmation_executed = false`) |
+| **누적 자원 사용 계측** | 432 runs, 414,720 queries, 4,147,200,000 sample evaluations, 3,162.9717s wall time (~52.7 min) |
+| **공개 아티팩트 및 시각화** | [`benchmark_results/pso_v7_heavy_cross_split.json`](benchmark_results/pso_v7_heavy_cross_split.json), [`benchmark_results/pso_v7_heavy_cross_split.csv`](benchmark_results/pso_v7_heavy_cross_split.csv), [`history_plt/pso_v7_heavy_cross_split.png`](history_plt/pso_v7_heavy_cross_split.png) |
+| **반복 결정 로그 경로** | [`.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/decision-log.md`](.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/decision-log.md) |
+
+
+
+#### 6.14.4 재현 실행 및 아티팩트 발행 명령
+
+```shell
+# 1. 교차 분할 탐색 미션 실행 (개발 단계)
+uv run --no-sync python test/heavy_pso_cross_split.py --phase development --device mps
+
+# 2. 개별 변형 평가 실행 예시
+uv run --no-sync python test/evaluate_heavy_cross_split.py --development .omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0001-development.json --output .omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0001-development.json
+
+# 3. 공개 아티팩트 및 시각화 생성 명령
+uv run --no-sync python test/publish_heavy_cross_split.py --source-dir .omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z --output-json benchmark_results/pso_v7_heavy_cross_split.json --output-csv benchmark_results/pso_v7_heavy_cross_split.csv --output-plot history_plt/pso_v7_heavy_cross_split.png
+```
+
+---
+
+### 6.15 학습 후 예측공간 PSO 앙상블 연구 (POST-TRAINING-PSO-ENSEMBLE 1.1.0)
+
+#### 6.15.1 연구 질문과 설계
+
+본 연구는 이미 학습된 CompactCNN의 예측을 재사용하여, 다섯 모델의 출력 확률을 하나의 가중 평균으로 결합할 때 저차원 PSO가 유용한지를 평가했습니다. MNIST와 FashionMNIST 각각에 대해 split seed **20260904**, 50,000개 search 샘플과 10,000개 validation 샘플을 사용했고, 정규화 통계도 search 샘플에서만 계산했습니다. 모델 pool은 seeds 201~205의 독립 CompactCNN(각 **9,098 parameters**) 다섯 개이며, 각 모델은 Adam 10 epochs, learning rate 0.001, batch size 256으로 학습했습니다. 다섯 모델의 validation 확률 캐시 shape은 `[5, 10000, 10]`이고, 최적화 중 base CNN forward pass는 0회였습니다.
+
+최적화 변수는 다섯 출력의 비음수 합이 1인 simplex 가중치 $w$뿐입니다. 따라서 이는 **prediction-space ensemble**이며, 파라미터를 평균내는 model soup가 아닙니다. Model soup의 weight averaging과 permutation 정렬을 다루는 문헌은 이 연구의 조작이나 결론을 뒷받침하는 직접적인 비교가 아닙니다 [arXiv:2203.05482](https://arxiv.org/abs/2203.05482), [arXiv:2209.04836](https://arxiv.org/abs/2209.04836). 비교 방법은 uniform, validation NLL에 대한 uniform temperature scaling, simplex 제약 SLSQP, 그리고 PSO입니다. PSO는 constriction movement, loss renewal, 30 particles, particle bounds $[-4,4]$, reflective boundary, velocity limit ratio 0.1, initial position noise 0, swarm seeds 301~303을 고정했습니다.
+
+#### 6.15.2 누수 방지와 사전 선언된 반복
+
+- 모델 학습, temperature fitting, SLSQP/PSO 가중치 선택은 모두 search/validation 단계에서만 수행했습니다. 공식 test split은 정책 동결 전 로드 0회·평가 0회였습니다.
+- Iteration 0의 독립 evaluator가 per-workload test-seal field lookup을 교정한 뒤 wall-efficiency gate만 실패한 것을 확인했습니다. 품질·안정성 gate와 세 swarm seed의 수렴 결과는 유지하고, 결정 로그에 따라 PSO epochs만 50에서 30으로 줄였습니다. pool, objective, seed, split, baseline, threshold, selection rule은 바꾸지 않았습니다.
+- 동결된 정책이 모든 development gate를 통과한 뒤에만 공식 test를 dataset별 1회 로드하여 pool 5회 forward와 50-epoch single 1회 forward로 확인했습니다. 그 뒤의 tuning/rerun은 0회입니다. 이 순서로 validation 선택과 one-shot test 확인을 분리했지만, 하나의 split과 하나의 final test endpoint만 사용했다는 한계는 남습니다.
+
+Iteration 0(30 particles × 50 epochs)은 seed당 1,500 objective evaluations를 사용했습니다. PSO는 SLSQP와 같은 six-decimal validation NLL에 도달했지만, median one-seed wall ratio가 MNIST **13.14%**, FashionMNIST **12.05%**로 frozen 10% ceiling을 넘었습니다. MNIST validation NLL은 PSO/SLSQP **0.045902**, uniform **0.046385**, 10-epoch reference **0.060105**, equal-epoch-budget 50-epoch single **0.073988**였고, FashionMNIST는 각각 **0.285338**, **0.286751**, **0.303799**, **0.289660**이었습니다. SLSQP는 workload당 23 evaluations와 약 0.011초, PSO는 workload당 1,500 evaluations와 약 2.98~3.29초를 사용했으며, uniform temperature는 두 workload에서 PSO보다 낮은 validation NLL을 보였습니다. 이 결정과 실패 사유는 [post-training decision log](.omc/autoresearch/post-training-pso-ensemble/runs/20260904T093144Z/decision-log.md)에 기록되어 있습니다.
+
+Iteration 1은 다른 조건을 바꾸지 않고 30 particles × 30 epochs로 축소했습니다. seed당 **900 queries**와 **9,000,000 candidate-sample evaluations**를 사용했고, 세 swarm seed가 모두 같은 six-decimal PSO NLL을 재현했습니다. Runner의 13개 집계 gate와 독립 evaluator가 재계산한 14개 development hard gate가 모두 통과했습니다.
+
+#### 6.15.3 Validation 및 one-shot test 결과
+
+아래 값은 accuracy(%) / NLL이며, PSO 행은 validation에서 frozen selected seed 301을 사용한 결과입니다. SLSQP와 PSO의 validation NLL은 두 dataset 모두 six-decimal 수준에서 같지만, test에서는 마지막 decimal 차이가 남습니다.
+
+| 방법 | MNIST validation | MNIST test (one-shot) | FashionMNIST validation | FashionMNIST test (one-shot) |
+| --- | ---: | ---: | ---: | ---: |
+| 10-epoch single | 98.23 / 0.060105 | 98.47 / 0.044991 | 89.47 / 0.303799 | 88.90 / 0.314516 |
+| 50-epoch single (equal epoch budget) | 98.52 / 0.073988 | 98.60 / 0.062102 | 90.32 / 0.289660 | 89.93 / 0.302348 |
+| Uniform ensemble | 98.63 / 0.046385 | 98.86 / 0.036184 | 90.28 / 0.286751 | 89.65 / 0.293522 |
+| Uniform + temperature | 98.63 / 0.045355 | 98.86 / 0.034129 | 90.28 / 0.285048 | 89.65 / 0.291996 |
+| SLSQP simplex weights | 98.60 / 0.045902 | 98.83 / 0.036179 | 90.42 / 0.285338 | 89.54 / 0.291696 |
+| PSO simplex weights | 98.61 / 0.045902 | 98.83 / 0.036178 | 90.42 / 0.285338 | 89.54 / 0.291700 |
+
+Evaluator의 cross-dataset mean은 equal-budget single 대비 validation NLL **19.726% 감소**와 accuracy **+0.095%p**, test NLL **22.633% 감소**와 accuracy **-0.080%p**였습니다. 이는 PSO가 단일 모델보다 NLL을 낮추면서도 uniform 대비 사전 선언된 regression gate를 넘지 않았다는 기술통계이지, PSO의 일반적 정확도 우월성은 아닙니다. Test에서 uniform+temperature는 MNIST에서 PSO보다 NLL이 낮고 accuracy가 **0.03%p 높았습니다**. FashionMNIST에서는 uniform+temperature NLL이 **0.291996**으로 PSO의 **0.291700**보다 높았지만, accuracy는 **0.11%p 높았습니다**.
+
+#### 6.15.4 계산비용과 full-weight G8과의 기술적 비교
+
+두 iteration을 합친 post-training study의 PSO 연구 비용은 **14,400 queries**, **144,000,000 candidate-sample evaluations**, research wall time **30.2907초**였습니다. 이 중 최종 Iteration 1은 **5,400 queries**, **54,000,000 candidate-sample evaluations**, research wall time **11.1512초**였고, validation에서 선택된 endpoint의 production wall time은 **3.7888초**였습니다. 다음 비율은 모두 **Iteration 1 내부 비교**이며 두 iteration 합산 비용을 한 iteration의 Adam/pool 학습 비용으로 나눈 값이 아닙니다. 선택된 production PSO 총시간을 Iteration 1의 다섯 모델 pool 학습 총시간 **44.4624초**로 나눈 비율은 정확히 **8.521376%**(소수 셋째 자리 반올림 **8.521%**)입니다. Development gate가 직접 확인한 workload별 median one-seed 비율은 MNIST **8.563655%**, FashionMNIST **8.479599%**이며, Iteration 1 artifact의 `pso_to_pool_wall_ratio`는 이 두 workload 비율의 중앙값 **8.521627%**(소수 셋째 자리 반올림 **8.522%**)입니다. 두 workload 모두 10% ceiling 아래였습니다. Iteration 1의 SLSQP는 workload당 23회, 총 **46 evaluations**, 총 **0.0201초**였습니다. Validation cache는 dataset당 pool 5회와 long single 1회, 총 12 forward passes를 사용했습니다. 앙상블은 모델 다섯 개를 보존하고 prediction inference도 다섯 번 수행하므로 single model 대비 storage/inference 경로가 **5배**입니다. 이 비용을 포함해도 …
+
+다음 표는 같은 CompactCNN parameter count를 사용한 [HEAVY-TASK-PSO-V6 artifact](benchmark_results/pso_v6_heavy_tasks.json)의 full-weight G8 semantic control과의 **기술적(descriptive) 비교**입니다. G8은 9,098개 전가중치를 직접 탐색한 12 particles × 80 epochs, fixed-10k validation, seeds 101~103 실행입니다. Post-training 행은 validation에서 선택된 PSO seed 301의 endpoint이고, G8 행은 세 seed의 평균입니다. 또한 post-training은 5개 모델의 5차원 prediction-space weight를 탐색하므로 두 행은 요약 통계, 목적함수, 최적화 공간이 모두 다릅니다.
+
+| 연구/방법 | 요약 통계 | 최적화 공간 | MNIST validation accuracy / NLL | FashionMNIST validation accuracy / NLL | 공식 test |
+| --- | --- | --- | ---: | ---: | --- |
+| Post-training PSO (Iteration 1) | validation-selected seed 301 | 5-way prediction simplex | 98.61% / 0.045902 | 90.42% / 0.285338 | 98.83% / 0.036178; 89.54% / 0.291700 |
+| Full-weight CompactCNN G8 (V6) | seeds 101~103 mean | 9,098 weights | 49.1533% / 1.518089 | 47.0033% / 1.511217 | 로드/평가 0회 |
+
+선택 endpoint와 3-seed mean 사이의 기술통계 차이는 MNIST에서 **+49.4567%p, NLL -1.472187**, FashionMNIST에서 **+43.4167%p, NLL -1.225879**(post-training PSO minus G8)입니다. 그러나 이 차이는 짝지어진 추정량이 아니며, model-soup 대 full-weight PSO의 인과 비교나 일반화 증거도 아닙니다. V6 G8의 split seed는 **20260902**, 공식 test는 봉인되었고, post-training study는 split seed **20260904**에서 이미 Adam으로 학습된 pool을 사용했습니다. V6 전체 study의 자원은 30,720 queries, 245,760,000 sample evaluations, summed optimization wall time 188.7283초, validation wall time 6.3826초였으며, 이 수치 역시 네 workload와 G0/G5/G6/G8 실행을 합친 값입니다. 따라서 full-weight G8 수치는 “전가중치 PSO를 실용적 학습기로 판정하지 않는다”는 기존 feasibility 결과를 보강하지만, post-training 앙상블의 test accuracy를 설명하는 대조군으로 사용하지 않습니다.
+
+#### 6.15.5 문헌과 해석의 경계
+
+Deep ensembles는 여러 독립 predictor의 predictive uncertainty를 실용적으로 추정할 수 있음을 보였고([arXiv:1612.01474](https://arxiv.org/abs/1612.01474)), temperature scaling은 단일 scalar로 calibration을 개선하는 간단한 post-processing으로 제시되었습니다([arXiv:1706.04599](https://arxiv.org/abs/1706.04599)). 본 연구에서 uniform+temperature가 validation/test NLL과 ECE를 개선한 관측은 이 두 문헌과 방향이 일치하지만, 두 dataset·한 split의 결과를 넘어선 보장은 아닙니다. PSO로 diversity와 accuracy를 함께 고려한 weighted ensemble을 구성한 선행 연구([DOI:10.3390/a13100255](https://doi.org/10.3390/a13100255))도 있으나, 그 연구는 mixed-binary learner selection과 UCI dataset들을 포함하는 다른 설계입니다. 또한 초기 신경망 ensemble 연구([DOI:10.1016/0893-6080(92)90023-1](https://doi.org/10.1016/0893-6080(92)90023-1))는 ensemble의 일반적 동기를 제공할 수 있을 뿐, 본 PSO 비용 비교의 실험적 근거는 아닙니다.
+
+#### 6.15.6 한계와 결정
+
+1. **선택 편향과 표본 범위**: validation split 하나, dataset 두 개, CompactCNN 하나, PSO swarm seed 세 개뿐입니다. validation에서 방법과 PSO seed를 선택한 뒤 test를 한 번 확인했으므로 test leakage는 피했지만, 반복 split·외부 dataset·독립 replication은 없습니다.
+2. **비동등한 대조군**: 50-epoch single은 pool의 합산 epoch와 맞춘 equal-epoch-budget 비교이며, 정확한 hardware FLOP 또는 병렬화 비용 동등성을 증명하지 않습니다. V6 G8은 전가중치 직접 탐색이고 split과 objective가 달라 post-training과의 accuracy/NLL 차이를 causal effect로 읽을 수 없습니다.
+3. **저차원 smooth objective의 특수성**: 다섯 확률 출력의 simplex NLL은 비교적 매끄러운 저차원 함수라서, PSO 900 evaluations가 SLSQP 23 evaluations와 같은 NLL을 얻은 사실은 이 설정에서의 redundancy를 보여줍니다. 모든 비선형·불연속 목적함수에서 PSO가 중복된다는 뜻은 아닙니다.
+4. **저장·추론 비용**: 다섯 모델을 보존하고 다섯 출력 forward를 수행해야 하므로 single model보다 5배 경로가 필요합니다. 본 연구는 이 ensemble overhead를 제거하거나 model soup으로 대체하지 않았습니다.
+
+**결정**: smooth prediction-space NLL에는 먼저 **uniform + temperature**를 사용하고, 명시적인 simplex weight가 필요하면 **SLSQP**를 우선합니다. PSO는 현재 연구에서 SLSQP보다 품질을 추가로 개선하지 못하면서 더 많은 query와 wall time을 사용했으므로 이 경로의 기본 optimizer로 채택하지 않습니다. 향후 PSO는 gradient가 없거나 불연속·이산인 architecture/subset/diversity 선택 문제처럼 SLSQP가 직접 다루기 어려운 목적함수에서만 별도 protocol과 leakage 방지 확인을 거쳐 연구합니다. 이 결론은 PSO 전체의 실패 선언이나 full-weight G8과의 일반적 우열 주장이 아니라, 본 post-training prediction-space study의 bounded decision입니다.
+
+**출력 아티팩트**: [`benchmark_results/pso_v8_post_training_ensemble.json`](benchmark_results/pso_v8_post_training_ensemble.json), [`benchmark_results/pso_v8_post_training_ensemble.csv`](benchmark_results/pso_v8_post_training_ensemble.csv), [`benchmark_results/pso_v8_post_training_ensemble_evaluation.json`](benchmark_results/pso_v8_post_training_ensemble_evaluation.json), [`history_plt/pso_v8_post_training_ensemble.png`](history_plt/pso_v8_post_training_ensemble.png), [decision log](.omc/autoresearch/post-training-pso-ensemble/runs/20260904T093144Z/decision-log.md).
+
+
+
+
+## 7. 결과 해석 및 실무 권고사항 (Interpretation & Recommendations)
+
+1. **고전 무브먼트 기법 선택**:
+ - Protocol 2.0.0의 5개 워크로드 고정 예산에서는 `constriction`과 `inertia`가 가장 낮은 평균 순위를 기록했습니다. 새로운 워크로드에서는 둘을 우선 비교하되 보편적 우위로 간주하지 않아야 합니다.
+ - 확장 MNIST 연구에서는 새 `local_best`의 반경 4 후보가 동일 30×80 held-out 확인에서 가장 높은 평균 정확도(62.64%)와 가장 낮은 손실(1.211368)을 기록했습니다. 다른 데이터셋에서는 별도 검증이 필요합니다.
+2. **`adaptive_moment` 독자 기법**:
+ - 기존 ablation의 $\lambda=0.10$은 해당 10개 프로필 중 미분 무관 최고 정확도였지만, 확장 search에서 선택된 $\lambda=0.06$/step 0.5는 동일 예산 held-out 확인에서 `local_best`와 `inertia`보다 낮았습니다.
+ - 더 많은 파티클은 80세대를 유지해 총 평가량을 늘릴 때 성능을 높였고, particle-epochs를 고정하면 낮아졌습니다. 파티클 수와 계산 예산을 함께 보고 선택해야 합니다.
+ - 120개 파티클에서는 80세대가 충분한 수렴 horizon이 아니었습니다. 이 워크로드에서 계산 예산이 허용되면 더 긴 horizon을 사용하되, 테스트 체크포인트가 아니라 별도 validation metric으로 중단 시점을 결정해야 합니다.
+ - 공식 MNIST 전체 학습에서는 240세대 정확도가 87.70%로 2k-fitness 연구보다 높았습니다. 다만 full objective와 PCA 적합 범위가 함께 달라졌으므로 full-data 사용 하나의 인과 효과로 분리하지 않습니다.
+3. **`quantum` 기법**:
+ - 이 후보 범위의 QPSO는 held-out 정확도 48.58%로 가장 낮았습니다. 하나의 워크로드 결과이며 QPSO 일반 성능으로 해석하지 않습니다.
+4. **Adam refinement**:
+ - 경사도 사용이 허용될 때 `tuned_adam_100_lr.01`은 기존 ablation에서 가장 높은 정확도와 가장 낮은 손실을 기록했습니다. 순수 미분 무관 방법과 별도 범주로 비교해야 합니다.
+5. **초기화 선택**:
+ - 기존 PCA32 ablation에서 `uniform` 초기화는 `model_noise`보다 평균 정확도가 4.64%p 낮았습니다. 이는 해당 경계·모델·예산에 한정된 관찰입니다.
+
+6. **딥러닝 아키텍처 및 PSO 역할 권고사항 (Deep Accuracy Insights)**:
+ - 측정된 설정에서 실무적 권장 경로는 **Compact CNN + Adam**입니다.
+ - 9,098개 CNN 전가중치를 직접 탐색한 PSO는 이 고정 예산에서 역전파를 대체하지 못했습니다. PSO를 딥러닝 파이프라인에 유지하려면 전가중치 대체보다 저차원 아키텍처·하이퍼파라미터 탐색 후 Adam으로 가중치를 학습하는 역할 분담이 합리적입니다. 이 역할 분담 자체는 본 프로토콜에서 비교하지 않은 공학적 권고입니다.
+7. **희소 부호 해시 부분공간·단계적 평가·스웜 앙상블 탐색 권고사항 (V5 Insights)**:
+ - V5의 동일 30p × 160e 파일럿에서는 희소 부호 해시 부분공간(290~4096차원)보다 전가중치(9,098차원) 검증 성능이 높았습니다. 그러나 V6 진단에서 동일 latent radius가 차원이 작을수록 decoded per-parameter RMS를 축소하는 교란이 확인됐으므로, 이 결과는 부분공간 자체의 열위 근거가 아닙니다.
+ - 단계적 표본 확장(2k→10k→50k) 적용 시 목적 함수 변경에 맞춰 pbest 재평가를 수행하여 수렴 편향을 방지해야 합니다.
+ - 스웜 내 검증 상위 다양성 파티클 기반 Top-5 앙상블은 단일 모델 대비 정확도(+3.77%p)와 NLL/Brier를 개선하였으나, ECE가 악화(+0.079042)되었습니다. 단순히 파티클 다양성이나 손실 잔여물이 높다고 해서 일반화나 신뢰성이 비례하여 향상된다고 가정하지 않아야 합니다.
+8. **V6 탐색 구조 권고사항**:
+ - V5의 zero-velocity/no-mutation/normalized ±3 묶음은 동일 2k·60p×420e 조건에서 기존 `Optimizer`보다 5.39%p 낮았습니다. mutation·초기 속도·±6 경계를 복원한 G5/G6은 사전 회복 기준을 통과했으므로 다음 탐색은 G6을 기준으로 진행합니다.
+ - global RMS coordinate scale은 per-tensor SD보다 낮았으므로 좌표 정규화 자체를 제거하지 않습니다. mutation과 경계 확장의 독립 효과는 아직 3-시드 확인 전이므로 각각을 확정 원인으로 표현하지 않습니다.
+9. **더 무거운 태스크에 대한 PSO 역할 권고사항**:
+ - 55,338개 파라미터와 FashionMNIST에서도 모든 실행이 finite했고 초기 모델 대비 개선됐으므로 기술적 실행 가능성은 확인됐습니다. 그러나 41.03~49.15% validation accuracy는 전가중치 PSO를 실용적 학습 경로로 권고할 근거가 아닙니다.
+ - 파라미터 수 증가로 swarm state가 6.08배 증가하고 처리량이 대략 절반으로 감소했습니다. 다음 확장 실험은 더 큰 전가중치 모델보다 저차원 subspace/협력적 block 탐색 또는 PSO 기반 하이퍼파라미터 탐색을 우선해야 합니다. 이 대안들의 성능은 본 프로토콜에서 측정하지 않았습니다.
+---
+
+## 8. 연구 한계점 (Limitations)
+
+1. **소규모 샘플 사이즈 ($n=5$) 및 신뢰구간 측정 한계**:
+ - 본 벤치마크는 무작위 시드 5개(41~45 및 46~50)에 대한 측정을 바탕으로 하였습니다. 샘플 크기가 $n=5$로 제한되어 일부 지표에서 표준편차가 크며, 95% 신뢰구간(CI)의 범위를 좁히는 데 한계가 있습니다.
+2. **순위(Rank) 지표의 서열적(Ordinal) 특성**:
+ - 평균 순위(Mean Rank) 지표는 절대적인 성능 격차 수치를 반영하지 않고 상대적인 순위 수치만을 반영합니다. 따라서 순위 차이가 절대적인 손실/정확도 차이와 정비례하지 않습니다.
+3. **`tuned_full_evaluation` 비교 시 교란 요인 (Confounders)**:
+ - `tuned_full_evaluation` (3,000개 전체 데이터)과 고정 서브셋 기법(2,000개 서브셋) 간의 손실 수치 비교는 평가에 사용된 데이터 샘플 수 및 배치 연산 차이가 개입된 교란 요인을 포함하고 있습니다.
+4. **소형/얕은 신경망 모델 범위 한계**:
+ - 메인 및 튜닝 평가 대부분은 1~2개 레이어의 소형 MLP와 PCA32 선형 모델이며, 딥 프로토콜도 9,098개 파라미터 Compact CNN 하나로 제한됩니다. 수만~수억 개 파라미터 모델로의 직접 일반화에는 근거가 부족합니다.
+
+5. **확장 튜닝의 선택 불확실성**:
+ - 32개 후보 search는 시드 3개만 사용했습니다. validation 차이가 작은 후보의 순위는 추가 시드에서 바뀔 수 있습니다.
+6. **파티클 스케일링의 계산량 차이**:
+ - 80세대 고정 비교는 파티클 수와 함께 총 평가량이 증가합니다. 약 2,400 particle-epochs 고정 비교는 평가 횟수만 근사적으로 맞추며 실제 MPS 실행 비용은 동일하지 않습니다.
+
+7. **Epoch checkpoint 테스트 반복 관찰**:
+ - 80~240세대 궤적은 같은 테스트 1,000개를 반복 평가한 진단 결과입니다. 이를 근거로 epoch를 선택하면 테스트셋 누수가 되므로 실제 stopping rule에는 별도 validation split이 필요합니다.
+
+8. **Full MNIST 모델 범위와 반복 테스트 관찰**:
+ - train/test 전체 split을 사용했지만 PCA32 선형 모델 실험입니다. 원본 영상 공간 및 CNN으로 일반화하지 않으며, test 10,000개 checkpoint를 반복 관찰해 epoch를 선택하지 않습니다.
+
+9. **Deep Accuracy 프로토콜의 표본 수($n=3$) 및 탐색 공간 제약**:
+ - Deep Accuracy 실험은 $n=3$ 시드로 수행된 기술적(descriptive) 비교이며 통계적 유의성 검정을 제공하지 않습니다. 또한 PSO 30 파티클 × 40 세대의 고정 예산과 고정 서브셋(2,000개) 평가 조건을 사용하였으므로, 파티클 수나 세대를 무한히 늘린 경우의 가설적 한계 성능을 수식적으로 증명한 것은 아닙니다. 그럼에도 9,098개 파라미터 전가중치 탐색에서 경사도 대비 극심한 열위(36.76% vs 98.53%)는 고차원 전가중치 PSO 적용의 실질적 한계를 명확히 나타냅니다.
+
+10. **MNIST-PSO-RAW-V5 프로토콜의 범위와 불확실성**:
+ - 부분공간 선택은 단일 파일럿 시드(91), 확인은 3개 시드와 Compact CNN 한 구조, 원본 MNIST 한 데이터셋에 한정됩니다. 60p × 600e 단계적 탐색의 단일 모델 정확도(83.23%)와 앙상블 정확도(87.00%)는 비동등 계산량의 v4 Adam 10-epoch 평균(98.53% ± 0.16%)보다 각각 15.30%p와 11.53%p 낮았습니다.
+ - 앙상블은 단일 모델보다 정확도와 NLL/Brier가 개선되고 예측 불일치도 0.1585를 보였지만, ECE도 0.085242에서 0.164284로 높아졌습니다. 이 동시 관찰만으로 다양성이나 손실이 개선 또는 보정 악화의 원인이라고 결론 내릴 수 없습니다.
+11. **MNIST-PSO-RAW-V6 screen/confirmation 범위**:
+ - G0–G8 screen은 단일 seed 91이므로 요인별 material 판정은 후보 선별 근거입니다. 3-시드 confirmation은 G0/G1/G5/G6/G8만 포함하여 전체 구조 회복과 scale/radius 판단만 확인했습니다.
+ - G5와 G6이 G8에 근접했다는 결과는 동일 2k 목적함수와 60p×420e 예산에 한정됩니다. 50k objective, 더 긴 horizon, 다른 초기 모델, 외부 데이터에 대한 성능을 보장하지 않습니다.
+ - 공식 test split을 사용하지 않았으므로 V6 Phase B 수치는 validation 결과이며 V5의 공식 test 정확도와 직접적인 paired test 비교가 아닙니다.
+12. **HEAVY-TASK-PSO-V6의 validation 재사용 및 예산 한계**:
+ - 단일 seed screen에서 normalized 방법을 선택한 뒤 같은 validation 10,000개로 3-시드 확인 결과를 보고했으므로 선택 편향이 남습니다. 공식 test split을 로드하지 않았고 외부 일반화 성능은 측정하지 않았습니다.
+ - 12 particles × 80 epochs·fixed-10k endpoint는 계산상 feasibility만 판정합니다. 세대 궤적, validation 기반 조기 중단, 50k objective, Adam 동예산 비교가 없으므로 수렴 완료·최대 도달 성능·계산 효율 우월성을 주장하지 않습니다.
+ - FashionMNIST는 설계상 데이터 난도 축으로 사용했지만 measured endpoint가 MNIST보다 일관되게 낮지 않았습니다. 따라서 이 실행만으로 데이터 난도 증가의 인과 효과를 분리하지 않습니다.
+13. **Heavy PSO 교차 분할 강건성 한계 (Cross-Split Robustness Failure)**: §6.14의 두 개발 분할(20260905/20260906)에서 동결 정책과 8회 결정의 9개 변형 모두 gate를 통과하지 못했습니다. 따라서 `fixed_global_hybrid_v3`의 이전 단일 분할 개선은 측정한 새 분할에서 재현되지 않았고, 이 정책은 보존하지 않습니다(`retained_policy = null`). 이 결과는 두 validation 분할과 고정 예산에 한정되며, 공식 test나 외부 데이터 일반화 성능을 측정하지 않았습니다.
+---
+## 9. 재현 명령 및 결과 데이터 아티팩트 (Reproducibility & Artifacts)
+
+### 9.1 재현 실행 명령 (Reproducibility Command)
+
+```shell
+# uv 환경에서 동일한 벤치마크 수트 전체 실행 (MPS 디바이스 사용)
+uv run --locked --extra examples python test/benchmark_suite.py --device mps
+
+# 검증 선택, held-out 확인, Adaptive Moment 파티클 스케일링
+uv run --locked --extra examples python test/tuning_suite.py --device mps
+
+# 120p×80e Adaptive Moment 파티클 스케일링 재현성 검증 (exact-replay + independent seeds)
+uv run --locked --extra examples python test/reproduce_scaling.py --device mps
+# 120p Adaptive Moment 연속 240-epoch 수렴 진단
+uv run --locked --extra examples python test/epoch_convergence.py --device mps
+# 공식 MNIST 60k/10k 전체 학습, 120p×240e
+uv run --locked --extra examples python test/full_mnist_study.py --device mps
+# 공식 MNIST 딥 신경망 아키텍처 및 최적화기 비교 (Deep Accuracy 1.0.0)
+uv run --locked --extra examples python test/deep_accuracy_study.py --device mps
+# 희소 부호 해시 부분공간·단계적 평가·스웜 앙상블 탐색 (MNIST-PSO-RAW-V5 1.0.0)
+uv run --locked --extra examples python test/deep_pso_methods.py --device mps
+# V5 탐색 구조 회귀 원인 분리 (MNIST-PSO-RAW-V6 1.0.0 Phase A/B)
+uv run --locked --extra examples python test/deep_pso_v6.py --phase all --device mps
+# 더 큰 CNN 및 FashionMNIST 전가중치 PSO feasibility screen/confirmation
+uv run --no-sync python test/heavy_task_feasibility.py --stage all --device mps
+# Heavy PSO 교차 분할 강건성 탐색/평가/발행
+uv run --no-sync python test/heavy_pso_cross_split.py --phase development --device mps
+uv run --no-sync python test/evaluate_heavy_cross_split.py --development .omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0001-development.json --output .omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0001-development.json
+uv run --no-sync python test/publish_heavy_cross_split.py --source-dir .omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z --output-json benchmark_results/pso_v7_heavy_cross_split.json --output-csv benchmark_results/pso_v7_heavy_cross_split.csv --output-plot history_plt/pso_v7_heavy_cross_split.png
+```
+
+### 9.2 원천 결과 데이터 및 아티팩트 경로
+
+- **종합 JSON 벤치마크 데이터**: [`benchmark_results/pso_v4_benchmark.json`](benchmark_results/pso_v4_benchmark.json)
+- **메인 벤치마크 CSV**: [`benchmark_results/pso_v4_main_benchmark.csv`](benchmark_results/pso_v4_main_benchmark.csv)
+- **Ablation 벤치마크 CSV**: [`benchmark_results/pso_v4_ablation_benchmark.csv`](benchmark_results/pso_v4_ablation_benchmark.csv)
+- **확장 튜닝 JSON**: [`benchmark_results/pso_v4_tuning.json`](benchmark_results/pso_v4_tuning.json)
+- **후보 Search CSV**: [`benchmark_results/pso_v4_tuning_search.csv`](benchmark_results/pso_v4_tuning_search.csv)
+- **Held-out Confirmation CSV**: [`benchmark_results/pso_v4_tuning_confirmation.csv`](benchmark_results/pso_v4_tuning_confirmation.csv)
+- **Particle Scaling CSV**: [`benchmark_results/pso_v4_particle_scaling.csv`](benchmark_results/pso_v4_particle_scaling.csv)
+- **120p×80e 재현성 검증 JSON**: [`benchmark_results/pso_v4_120p80_replication.json`](benchmark_results/pso_v4_120p80_replication.json)
+- **120p×80e 재현성 검증 CSV**: [`benchmark_results/pso_v4_120p80_replication.csv`](benchmark_results/pso_v4_120p80_replication.csv)
+- **120p epoch 수렴 진단 JSON**: [`benchmark_results/pso_v4_epoch_convergence.json`](benchmark_results/pso_v4_epoch_convergence.json)
+- **120p epoch 수렴 진단 CSV**: [`benchmark_results/pso_v4_epoch_convergence.csv`](benchmark_results/pso_v4_epoch_convergence.csv)
+- **Full MNIST JSON**: [`benchmark_results/pso_v4_full_mnist.json`](benchmark_results/pso_v4_full_mnist.json)
+- **Full MNIST CSV**: [`benchmark_results/pso_v4_full_mnist.csv`](benchmark_results/pso_v4_full_mnist.csv)
+- **Deep Accuracy JSON**: [`benchmark_results/pso_v4_deep_accuracy.json`](benchmark_results/pso_v4_deep_accuracy.json)
+- **Deep Accuracy CSV**: [`benchmark_results/pso_v4_deep_accuracy.csv`](benchmark_results/pso_v4_deep_accuracy.csv)
+- **V5 Deep Methods JSON**: [`benchmark_results/pso_v5_deep_methods.json`](benchmark_results/pso_v5_deep_methods.json)
+- **V5 Deep Methods CSV**: [`benchmark_results/pso_v5_deep_methods.csv`](benchmark_results/pso_v5_deep_methods.csv)
+- **V6 Geometry Ablation JSON**: [`benchmark_results/pso_v6_phase_b.json`](benchmark_results/pso_v6_phase_b.json)
+- **V6 Geometry Ablation CSV**: [`benchmark_results/pso_v6_phase_b.csv`](benchmark_results/pso_v6_phase_b.csv)
+- **Heavy Task Feasibility JSON**: [`benchmark_results/pso_v6_heavy_tasks.json`](benchmark_results/pso_v6_heavy_tasks.json)
+- **Heavy Task Feasibility CSV**: [`benchmark_results/pso_v6_heavy_tasks.csv`](benchmark_results/pso_v6_heavy_tasks.csv)
+- **Heavy PSO Cross-Split JSON**: [`benchmark_results/pso_v7_heavy_cross_split.json`](benchmark_results/pso_v7_heavy_cross_split.json)
+- **Heavy PSO Cross-Split CSV**: [`benchmark_results/pso_v7_heavy_cross_split.csv`](benchmark_results/pso_v7_heavy_cross_split.csv)
+- **결과 시각화 이미지**:
+ - [`history_plt/pso_v4_accuracy.png`](history_plt/pso_v4_accuracy.png)
+ - [`history_plt/pso_v4_loss.png`](history_plt/pso_v4_loss.png)
+ - [`history_plt/pso_v4_rank_heatmap.png`](history_plt/pso_v4_rank_heatmap.png)
+ - [`history_plt/pso_v4_runtime.png`](history_plt/pso_v4_runtime.png)
+ - [`history_plt/pso_v4_mnist_ablation.png`](history_plt/pso_v4_mnist_ablation.png)
+ - [`history_plt/pso_v4_extended_tuning.png`](history_plt/pso_v4_extended_tuning.png)
+ - [`history_plt/pso_v4_particle_scaling.png`](history_plt/pso_v4_particle_scaling.png)
+ - [`history_plt/pso_v4_epoch_convergence.png`](history_plt/pso_v4_epoch_convergence.png)
+ - [`history_plt/pso_v4_full_mnist.png`](history_plt/pso_v4_full_mnist.png)
+ - [`history_plt/pso_v4_deep_accuracy.png`](history_plt/pso_v4_deep_accuracy.png)
+ - [`history_plt/pso_v5_deep_methods.png`](history_plt/pso_v5_deep_methods.png)
+ - [`history_plt/pso_v6_phase_b.png`](history_plt/pso_v6_phase_b.png)
+ - [`history_plt/pso_v6_heavy_tasks.png`](history_plt/pso_v6_heavy_tasks.png)
+ - [`history_plt/pso_v7_heavy_cross_split.png`](history_plt/pso_v7_heavy_cross_split.png)
+
+### 9.3 소스 코드 및 레퍼런스 문헌 참조
+- **5단계 플러그인 구현 소스**: [`pso/plugins.py`](pso/plugins.py) 및 [`pso/optimizer.py`](pso/optimizer.py)
+- **V5 탐색 및 앙상블 스크립트**: [`test/deep_pso_methods.py`](test/deep_pso_methods.py)
+- **V6 탐색 구조 진단 스크립트**: [`test/deep_pso_v6.py`](test/deep_pso_v6.py)
+- **Heavy Task Feasibility 스크립트**: [`test/heavy_task_feasibility.py`](test/heavy_task_feasibility.py)
+- **Heavy PSO Cross-Split 탐색/평가/발행 스크립트**: [`test/heavy_pso_cross_split.py`](test/heavy_pso_cross_split.py), [`test/evaluate_heavy_cross_split.py`](test/evaluate_heavy_cross_split.py), [`test/publish_heavy_cross_split.py`](test/publish_heavy_cross_split.py)
+- **고전 PSO 논문 DOI 및 알고리즘 구현 레퍼런스**: [`README.md` 참고 문헌 섹션](README.md#참고-문헌-primary-references--dois) 참조
diff --git a/benchmark_results/pso_v4_120p80_replication.csv b/benchmark_results/pso_v4_120p80_replication.csv
new file mode 100644
index 0000000..9f9daa0
--- /dev/null
+++ b/benchmark_results/pso_v4_120p80_replication.csv
@@ -0,0 +1,16 @@
+cohort,method,candidate_label,regimen,seed,n_particles,epochs,particle_epochs,train_loss,train_acc,test_loss,test_acc,test_mse,fit_time_sec,data_fingerprint,model_fingerprint,device,completed,error
+baseline,adaptive_moment,am_b0.06_s0.5,fixed_epoch,71,120,80,9600,0.6516683101654053,0.7950000166893005,0.8584634065628052,0.7360000014305115,0.037673790007829666,11.962705624988303,dfe645918ece54c0,0777bd52fd76272d,mps,True,
+baseline,adaptive_moment,am_b0.06_s0.5,fixed_epoch,72,120,80,9600,0.6982801556587219,0.7914999723434448,0.9025362133979797,0.7239999771118164,0.038956169039011,11.906837583053857,dfe645918ece54c0,6fcb6e473bdacbd2,mps,True,
+baseline,adaptive_moment,am_b0.06_s0.5,fixed_epoch,73,120,80,9600,0.7527623772621155,0.7749999761581421,1.001193642616272,0.6919999718666077,0.04309915751218796,10.664651792030782,dfe645918ece54c0,2e6c351372592f10,mps,True,
+baseline,adaptive_moment,am_b0.06_s0.5,fixed_epoch,74,120,80,9600,0.6858600974082947,0.784500002861023,0.8601324558258057,0.7350000143051147,0.03845023736357689,10.921957665821537,dfe645918ece54c0,4000fe3fb26ef207,mps,True,
+baseline,adaptive_moment,am_b0.06_s0.5,fixed_epoch,75,120,80,9600,0.6326538324356079,0.8125,0.889915406703949,0.7300000190734863,0.03931796923279762,10.411899874918163,dfe645918ece54c0,0966039f5ef7af88,mps,True,
+replay,adaptive_moment,am_b0.06_s0.5,fixed_epoch,71,120,80,9600,0.6516683101654053,0.7950000166893005,0.8584634065628052,0.7360000014305115,0.037673790007829666,11.090910458937287,dfe645918ece54c0,0777bd52fd76272d,mps,True,
+replay,adaptive_moment,am_b0.06_s0.5,fixed_epoch,72,120,80,9600,0.6982801556587219,0.7914999723434448,0.9025362133979797,0.7239999771118164,0.038956169039011,10.668682500021532,dfe645918ece54c0,6fcb6e473bdacbd2,mps,True,
+replay,adaptive_moment,am_b0.06_s0.5,fixed_epoch,73,120,80,9600,0.7527623772621155,0.7749999761581421,1.001193642616272,0.6919999718666077,0.04309915751218796,11.617381499847397,dfe645918ece54c0,2e6c351372592f10,mps,True,
+replay,adaptive_moment,am_b0.06_s0.5,fixed_epoch,74,120,80,9600,0.6858600974082947,0.784500002861023,0.8601324558258057,0.7350000143051147,0.03845023736357689,12.46007908298634,dfe645918ece54c0,4000fe3fb26ef207,mps,True,
+replay,adaptive_moment,am_b0.06_s0.5,fixed_epoch,75,120,80,9600,0.6326538324356079,0.8125,0.889915406703949,0.7300000190734863,0.03931796923279762,11.499297459144145,dfe645918ece54c0,0966039f5ef7af88,mps,True,
+independent,adaptive_moment,am_b0.06_s0.5,fixed_epoch,81,120,80,9600,0.7000858783721924,0.781000018119812,0.9081020355224609,0.7250000238418579,0.039418451488018036,10.6923490408808,dfe645918ece54c0,b9e1b8cbb9345add,mps,True,
+independent,adaptive_moment,am_b0.06_s0.5,fixed_epoch,82,120,80,9600,0.6899945139884949,0.796999990940094,0.9245963096618652,0.718999981880188,0.03965267166495323,11.110405791085213,dfe645918ece54c0,f1a0025f5b3b5b7c,mps,True,
+independent,adaptive_moment,am_b0.06_s0.5,fixed_epoch,83,120,80,9600,0.6943607330322266,0.7929999828338623,0.8056192398071289,0.7609999775886536,0.034950967878103256,10.71645870897919,dfe645918ece54c0,9cb7fe904bf992ac,mps,True,
+independent,adaptive_moment,am_b0.06_s0.5,fixed_epoch,84,120,80,9600,0.7076351046562195,0.7885000109672546,0.8160682320594788,0.7429999709129333,0.0366184301674366,10.859140583081171,dfe645918ece54c0,b833ebd886fce382,mps,True,
+independent,adaptive_moment,am_b0.06_s0.5,fixed_epoch,85,120,80,9600,0.6802449822425842,0.7875000238418579,0.8681835532188416,0.7319999933242798,0.038917701691389084,10.97266870806925,dfe645918ece54c0,e6bdf9e5d849521b,mps,True,
diff --git a/benchmark_results/pso_v4_120p80_replication.json b/benchmark_results/pso_v4_120p80_replication.json
new file mode 100644
index 0000000..bb2151e
--- /dev/null
+++ b/benchmark_results/pso_v4_120p80_replication.json
@@ -0,0 +1,1899 @@
+{
+ "replication_protocol_version": "1.0.0",
+ "source_tuning_protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "timestamp": "2026-09-01 23:24:38",
+ "device": "mps",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "baseline_json": "benchmark_results/pso_v4_tuning.json",
+ "source_tuning_timestamp": "2026-09-01 07:10:25",
+ "candidate_label": "am_b0.06_s0.5",
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ }
+ },
+ "data_fingerprint": "dfe645918ece54c0",
+ "criteria": {
+ "replay_seeds": [
+ 71,
+ 72,
+ 73,
+ 74,
+ 75
+ ],
+ "replay_max_abs_delta_tolerance": 0.005,
+ "require_replay_model_fingerprint_match": true,
+ "independent_seeds": [
+ 81,
+ 82,
+ 83,
+ 84,
+ 85
+ ],
+ "independent_mean_abs_diff_margin": 0.03,
+ "require_ci_overlap": true
+ },
+ "summaries": {
+ "baseline": {
+ "mean": 0.7234,
+ "std": 0.018188,
+ "median": 0.73,
+ "iqr": 0.011,
+ "ci95_t": 0.022583
+ },
+ "replay": {
+ "mean": 0.7234,
+ "std": 0.018188,
+ "median": 0.73,
+ "iqr": 0.011,
+ "ci95_t": 0.022583
+ },
+ "independent": {
+ "mean": 0.736,
+ "std": 0.016583,
+ "median": 0.732,
+ "iqr": 0.018,
+ "ci95_t": 0.02059
+ }
+ },
+ "comparison": {
+ "replay_per_seed_deltas": {
+ "71": 0.0,
+ "72": 0.0,
+ "73": 0.0,
+ "74": 0.0,
+ "75": 0.0
+ },
+ "replay_max_abs_delta": 0.0,
+ "replay_model_fingerprint_match": true,
+ "replay_pass": true,
+ "independent_mean_abs_diff": 0.0126,
+ "independent_mean_pass": true,
+ "baseline_ci95_t_interval": [
+ 0.700817,
+ 0.745983
+ ],
+ "independent_ci95_t_interval": [
+ 0.71541,
+ 0.75659
+ ],
+ "ci_overlap_pass": true,
+ "independent_pass": true,
+ "overall_pass": true
+ },
+ "baseline_runs": [
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 71,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6516683101654053,
+ "train_acc": 0.7950000166893005,
+ "train_mse": 0.028850017115473747,
+ "test_loss": 0.8584634065628052,
+ "test_acc": 0.7360000014305115,
+ "test_mse": 0.037673790007829666,
+ "fit_time_sec": 11.962705624988303,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0777bd52fd76272d",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_80e_fixed_epoch_seed71_e66d603db8f5",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 72,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6982801556587219,
+ "train_acc": 0.7914999723434448,
+ "train_mse": 0.030153820291161537,
+ "test_loss": 0.9025362133979797,
+ "test_acc": 0.7239999771118164,
+ "test_mse": 0.038956169039011,
+ "fit_time_sec": 11.906837583053857,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_80e_fixed_epoch_seed72_47cdadf9a983",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 73,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.7527623772621155,
+ "train_acc": 0.7749999761581421,
+ "train_mse": 0.032556530088186264,
+ "test_loss": 1.001193642616272,
+ "test_acc": 0.6919999718666077,
+ "test_mse": 0.04309915751218796,
+ "fit_time_sec": 10.664651792030782,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2e6c351372592f10",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_80e_fixed_epoch_seed73_78208b86e119",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 74,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6858600974082947,
+ "train_acc": 0.784500002861023,
+ "train_mse": 0.030640259385108948,
+ "test_loss": 0.8601324558258057,
+ "test_acc": 0.7350000143051147,
+ "test_mse": 0.03845023736357689,
+ "fit_time_sec": 10.921957665821537,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4000fe3fb26ef207",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_80e_fixed_epoch_seed74_e44bd395ec76",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 75,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6326538324356079,
+ "train_acc": 0.8125,
+ "train_mse": 0.02839995175600052,
+ "test_loss": 0.889915406703949,
+ "test_acc": 0.7300000190734863,
+ "test_mse": 0.03931796923279762,
+ "fit_time_sec": 10.411899874918163,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0966039f5ef7af88",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_80e_fixed_epoch_seed75_17aefd097619",
+ "regimen": "fixed_epoch"
+ }
+ ],
+ "replay_runs": [
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "replication_replay",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 71,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6516683101654053,
+ "train_acc": 0.7950000166893005,
+ "train_mse": 0.028850017115473747,
+ "test_loss": 0.8584634065628052,
+ "test_acc": 0.7360000014305115,
+ "test_mse": 0.037673790007829666,
+ "fit_time_sec": 11.090910458937287,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0777bd52fd76272d",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "replication_replay",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 72,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6982801556587219,
+ "train_acc": 0.7914999723434448,
+ "train_mse": 0.030153820291161537,
+ "test_loss": 0.9025362133979797,
+ "test_acc": 0.7239999771118164,
+ "test_mse": 0.038956169039011,
+ "fit_time_sec": 10.668682500021532,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "replication_replay",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 73,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.7527623772621155,
+ "train_acc": 0.7749999761581421,
+ "train_mse": 0.032556530088186264,
+ "test_loss": 1.001193642616272,
+ "test_acc": 0.6919999718666077,
+ "test_mse": 0.04309915751218796,
+ "fit_time_sec": 11.617381499847397,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2e6c351372592f10",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "replication_replay",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 74,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6858600974082947,
+ "train_acc": 0.784500002861023,
+ "train_mse": 0.030640259385108948,
+ "test_loss": 0.8601324558258057,
+ "test_acc": 0.7350000143051147,
+ "test_mse": 0.03845023736357689,
+ "fit_time_sec": 12.46007908298634,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4000fe3fb26ef207",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "replication_replay",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 75,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6326538324356079,
+ "train_acc": 0.8125,
+ "train_mse": 0.02839995175600052,
+ "test_loss": 0.889915406703949,
+ "test_acc": 0.7300000190734863,
+ "test_mse": 0.03931796923279762,
+ "fit_time_sec": 11.499297459144145,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0966039f5ef7af88",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "regimen": "fixed_epoch"
+ }
+ ],
+ "independent_runs": [
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "replication_independent",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 81,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.7000858783721924,
+ "train_acc": 0.781000018119812,
+ "train_mse": 0.03082381933927536,
+ "test_loss": 0.9081020355224609,
+ "test_acc": 0.7250000238418579,
+ "test_mse": 0.039418451488018036,
+ "fit_time_sec": 10.6923490408808,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "b9e1b8cbb9345add",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "replication_independent",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 82,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6899945139884949,
+ "train_acc": 0.796999990940094,
+ "train_mse": 0.02961476519703865,
+ "test_loss": 0.9245963096618652,
+ "test_acc": 0.718999981880188,
+ "test_mse": 0.03965267166495323,
+ "fit_time_sec": 11.110405791085213,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "f1a0025f5b3b5b7c",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "replication_independent",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 83,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6943607330322266,
+ "train_acc": 0.7929999828338623,
+ "train_mse": 0.029856808483600616,
+ "test_loss": 0.8056192398071289,
+ "test_acc": 0.7609999775886536,
+ "test_mse": 0.034950967878103256,
+ "fit_time_sec": 10.71645870897919,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "9cb7fe904bf992ac",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "replication_independent",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 84,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.7076351046562195,
+ "train_acc": 0.7885000109672546,
+ "train_mse": 0.03054513782262802,
+ "test_loss": 0.8160682320594788,
+ "test_acc": 0.7429999709129333,
+ "test_mse": 0.0366184301674366,
+ "fit_time_sec": 10.859140583081171,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "b833ebd886fce382",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "replication_independent",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 85,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6802449822425842,
+ "train_acc": 0.7875000238418579,
+ "train_mse": 0.0307244174182415,
+ "test_loss": 0.8681835532188416,
+ "test_acc": 0.7319999933242798,
+ "test_mse": 0.038917701691389084,
+ "fit_time_sec": 10.97266870806925,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "e6bdf9e5d849521b",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "regimen": "fixed_epoch"
+ }
+ ],
+ "completed": true,
+ "error": null
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v4_ablation_benchmark.csv b/benchmark_results/pso_v4_ablation_benchmark.csv
new file mode 100644
index 0000000..30beed2
--- /dev/null
+++ b/benchmark_results/pso_v4_ablation_benchmark.csv
@@ -0,0 +1,11 @@
+profile,dataset,method,n_particles,epochs,n_seeds,eval_acc_mean,eval_acc_std,eval_acc_median,eval_acc_iqr,eval_acc_ci95,eval_loss_mean,eval_loss_std,eval_loss_median,eval_loss_iqr,eval_loss_ci95,eval_mse_mean,eval_mse_std,train_acc_mean,train_loss_mean,runtime_seconds_mean,runtime_seconds_std,rank_acc,rank_loss
+adaptive_moment_.10,MNIST,adaptive_moment,30,80,5,0.63,0.018276,0.641,0.027,0.022692,1.243339,0.102561,1.253713,0.068197,0.127344,0.051633,0.002578,0.7099,0.978244,4.286662,0.289397,2,5
+adaptive_moment_.25,MNIST,adaptive_moment,30,80,5,0.5632,0.02938,0.569,0.034,0.03648,1.499979,0.119449,1.483628,0.043413,0.148313,0.06119,0.003677,0.6379,1.228023,3.290951,0.425997,8,7
+adaptive_moment_.50,MNIST,adaptive_moment,30,80,5,0.5186,0.039087,0.51,0.019,0.048532,1.683781,0.121571,1.683062,0.08627,0.150948,0.067331,0.003822,0.5705,1.4637,3.202502,0.269844,9,9
+inertia_canonical,MNIST,inertia,30,80,5,0.4676,0.024358,0.472,0.033,0.030244,1.720983,0.118092,1.699598,0.020267,0.146628,0.070356,0.002531,0.5277,1.528197,3.119898,0.30594,10,10
+inertia_tuned,MNIST,inertia,30,80,5,0.6162,0.05131,0.635,0.007,0.063709,1.2366,0.124281,1.194831,0.029657,0.154312,0.05278,0.005923,0.6931,0.999514,3.131882,0.408534,4,3
+tuned_adam_100_lr.01,MNIST,inertia,30,80,5,0.8558,0.002387,0.856,0.003,0.002964,0.470271,0.011931,0.472233,0.019931,0.014814,0.02164,0.000368,0.9158,0.298524,4.990688,0.434352,1,1
+tuned_full_evaluation,MNIST,inertia,30,80,5,0.6254,0.02805,0.624,0.029,0.034828,1.179009,0.050059,1.194071,0.052015,0.062156,0.051537,0.00241,0.687867,1.00514,3.377083,0.469302,3,2
+tuned_no_mutation,MNIST,inertia,30,80,5,0.6042,0.030376,0.607,0.003,0.037716,1.249836,0.084985,1.215945,0.022012,0.105521,0.053483,0.003055,0.6686,1.074396,3.347668,0.3431,6,6
+tuned_particle_reset,MNIST,inertia,30,80,5,0.6162,0.05131,0.635,0.007,0.063709,1.2366,0.124281,1.194831,0.029657,0.154312,0.05278,0.005923,0.6931,0.999514,4.176388,0.449217,5,4
+tuned_uniform_initialization,MNIST,inertia,30,80,5,0.5698,0.023952,0.575,0.017,0.02974,1.619196,0.157329,1.641514,0.149905,0.195347,0.061757,0.0042,0.616,1.345857,4.306866,0.442651,7,8
diff --git a/benchmark_results/pso_v4_benchmark.json b/benchmark_results/pso_v4_benchmark.json
new file mode 100644
index 0000000..a1bd247
--- /dev/null
+++ b/benchmark_results/pso_v4_benchmark.json
@@ -0,0 +1,30275 @@
+{
+ "benchmark_protocol_version": "2.0.0",
+ "version": "4.0.0",
+ "timestamp": "2026-08-31T07:17:57.927878+00:00",
+ "environment": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "runs": [
+ {
+ "run_id": "main_XOR_original_seed41_18771240821c",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "18771240821c",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ff7c5c0c14cb5935",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "original",
+ "profile": "original",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.007386879529803991,
+ "accuracy": 1.0,
+ "mse": 7.510842988267541e-05
+ },
+ "eval_metrics": {
+ "loss": 0.007386879529803991,
+ "accuracy": 1.0,
+ "mse": 7.510842988267541e-05
+ },
+ "runtime_seconds": 1.8426640420220792,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_original_seed42_4ad58c6711ab",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "4ad58c6711ab",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ce7542b765c31886",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "original",
+ "profile": "original",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.004583858884871006,
+ "accuracy": 1.0,
+ "mse": 3.7565998354693875e-05
+ },
+ "eval_metrics": {
+ "loss": 0.004583858884871006,
+ "accuracy": 1.0,
+ "mse": 3.7565998354693875e-05
+ },
+ "runtime_seconds": 2.238242666935548,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_original_seed43_73f21a367007",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "73f21a367007",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "af36176b8ad726d5",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "original",
+ "profile": "original",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.004551402293145657,
+ "accuracy": 1.0,
+ "mse": 3.9420083339791745e-05
+ },
+ "eval_metrics": {
+ "loss": 0.004551402293145657,
+ "accuracy": 1.0,
+ "mse": 3.9420083339791745e-05
+ },
+ "runtime_seconds": 1.6712233750149608,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_original_seed44_06693504cc0f",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "06693504cc0f",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "8e381587afeb224a",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "original",
+ "profile": "original",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.0002604134497232735,
+ "accuracy": 1.0,
+ "mse": 7.829999759678685e-08
+ },
+ "eval_metrics": {
+ "loss": 0.0002604134497232735,
+ "accuracy": 1.0,
+ "mse": 7.829999759678685e-08
+ },
+ "runtime_seconds": 1.6958581251092255,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_original_seed45_15d504c8e558",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "15d504c8e558",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "2f370bc749eaedb3",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "original",
+ "profile": "original",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.006005589850246906,
+ "accuracy": 1.0,
+ "mse": 5.5506381613668054e-05
+ },
+ "eval_metrics": {
+ "loss": 0.006005589850246906,
+ "accuracy": 1.0,
+ "mse": 5.5506381613668054e-05
+ },
+ "runtime_seconds": 2.0781680829823017,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_inertia_seed41_ad2094a72ef3",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "ad2094a72ef3",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ff7c5c0c14cb5935",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.009255236014723778,
+ "accuracy": 1.0,
+ "mse": 8.518801041645929e-05
+ },
+ "eval_metrics": {
+ "loss": 0.009255236014723778,
+ "accuracy": 1.0,
+ "mse": 8.518801041645929e-05
+ },
+ "runtime_seconds": 1.8728650419507176,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_inertia_seed42_9eea8ba11d4d",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "9eea8ba11d4d",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ce7542b765c31886",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.0037266211584210396,
+ "accuracy": 1.0,
+ "mse": 2.6833311494556256e-05
+ },
+ "eval_metrics": {
+ "loss": 0.0037266211584210396,
+ "accuracy": 1.0,
+ "mse": 2.6833311494556256e-05
+ },
+ "runtime_seconds": 1.7129027091432363,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_inertia_seed43_771306ac3b83",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "771306ac3b83",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "af36176b8ad726d5",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.005285806022584438,
+ "accuracy": 1.0,
+ "mse": 4.190824620309286e-05
+ },
+ "eval_metrics": {
+ "loss": 0.005285806022584438,
+ "accuracy": 1.0,
+ "mse": 4.190824620309286e-05
+ },
+ "runtime_seconds": 2.0683268748689443,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_inertia_seed44_f33e988957f7",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f33e988957f7",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "8e381587afeb224a",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 8.529236947651953e-05,
+ "accuracy": 1.0,
+ "mse": 7.4129111737875064e-09
+ },
+ "eval_metrics": {
+ "loss": 8.529236947651953e-05,
+ "accuracy": 1.0,
+ "mse": 7.4129111737875064e-09
+ },
+ "runtime_seconds": 2.0988389160484076,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_inertia_seed45_6e462201d91d",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "6e462201d91d",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "2f370bc749eaedb3",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.003801023820415139,
+ "accuracy": 1.0,
+ "mse": 2.8215974452905357e-05
+ },
+ "eval_metrics": {
+ "loss": 0.003801023820415139,
+ "accuracy": 1.0,
+ "mse": 2.8215974452905357e-05
+ },
+ "runtime_seconds": 2.0925519168376923,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_constriction_seed41_5dc0ccc001f4",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "5dc0ccc001f4",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ff7c5c0c14cb5935",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.005784815177321434,
+ "accuracy": 1.0,
+ "mse": 4.825989162782207e-05
+ },
+ "eval_metrics": {
+ "loss": 0.005784815177321434,
+ "accuracy": 1.0,
+ "mse": 4.825989162782207e-05
+ },
+ "runtime_seconds": 2.177875207969919,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_constriction_seed42_042b3a315a8a",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "042b3a315a8a",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ce7542b765c31886",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.0054346839897334576,
+ "accuracy": 1.0,
+ "mse": 4.186024307273328e-05
+ },
+ "eval_metrics": {
+ "loss": 0.0054346839897334576,
+ "accuracy": 1.0,
+ "mse": 4.186024307273328e-05
+ },
+ "runtime_seconds": 2.108115291921422,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_constriction_seed43_4bdb52657fc9",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "4bdb52657fc9",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "af36176b8ad726d5",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.005281048361212015,
+ "accuracy": 1.0,
+ "mse": 4.069419446750544e-05
+ },
+ "eval_metrics": {
+ "loss": 0.005281048361212015,
+ "accuracy": 1.0,
+ "mse": 4.069419446750544e-05
+ },
+ "runtime_seconds": 1.9424659160431474,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_constriction_seed44_b3f0740b2f45",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "b3f0740b2f45",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "8e381587afeb224a",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.003849876346066594,
+ "accuracy": 1.0,
+ "mse": 2.8525431844173e-05
+ },
+ "eval_metrics": {
+ "loss": 0.003849876346066594,
+ "accuracy": 1.0,
+ "mse": 2.8525431844173e-05
+ },
+ "runtime_seconds": 2.004753499990329,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_constriction_seed45_6e2b0a002a23",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "6e2b0a002a23",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "2f370bc749eaedb3",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 8.070276817306876e-05,
+ "accuracy": 1.0,
+ "mse": 6.607560276705726e-09
+ },
+ "eval_metrics": {
+ "loss": 8.070276817306876e-05,
+ "accuracy": 1.0,
+ "mse": 6.607560276705726e-09
+ },
+ "runtime_seconds": 1.705668875016272,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_fips_seed41_d8a276c17de7",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "d8a276c17de7",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ff7c5c0c14cb5935",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.614154040813446,
+ "accuracy": 0.75,
+ "mse": 0.2110060751438141
+ },
+ "eval_metrics": {
+ "loss": 0.614154040813446,
+ "accuracy": 0.75,
+ "mse": 0.2110060751438141
+ },
+ "runtime_seconds": 2.461878624977544,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_fips_seed42_42d04b907cd0",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "42d04b907cd0",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ce7542b765c31886",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.5686086416244507,
+ "accuracy": 0.5,
+ "mse": 0.19087998569011688
+ },
+ "eval_metrics": {
+ "loss": 0.5686086416244507,
+ "accuracy": 0.5,
+ "mse": 0.19087998569011688
+ },
+ "runtime_seconds": 2.5289090001024306,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_fips_seed43_07f3d1fdd7f8",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "07f3d1fdd7f8",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "af36176b8ad726d5",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.4886510372161865,
+ "accuracy": 1.0,
+ "mse": 0.1495770514011383
+ },
+ "eval_metrics": {
+ "loss": 0.4886510372161865,
+ "accuracy": 1.0,
+ "mse": 0.1495770514011383
+ },
+ "runtime_seconds": 2.4935093328822404,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_fips_seed44_779976b5aeb5",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "779976b5aeb5",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "8e381587afeb224a",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.5807976722717285,
+ "accuracy": 0.5,
+ "mse": 0.19726261496543884
+ },
+ "eval_metrics": {
+ "loss": 0.5807976722717285,
+ "accuracy": 0.5,
+ "mse": 0.19726261496543884
+ },
+ "runtime_seconds": 2.583402584074065,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_fips_seed45_85ffdca802ec",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "85ffdca802ec",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "2f370bc749eaedb3",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.47956302762031555,
+ "accuracy": 1.0,
+ "mse": 0.14570996165275574
+ },
+ "eval_metrics": {
+ "loss": 0.47956302762031555,
+ "accuracy": 1.0,
+ "mse": 0.14570996165275574
+ },
+ "runtime_seconds": 2.4448467078618705,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_clpso_seed41_dd01b225f5fc",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "dd01b225f5fc",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ff7c5c0c14cb5935",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.5562796592712402,
+ "accuracy": 0.5,
+ "mse": 0.18462540209293365
+ },
+ "eval_metrics": {
+ "loss": 0.5562796592712402,
+ "accuracy": 0.5,
+ "mse": 0.18462540209293365
+ },
+ "runtime_seconds": 2.2524965000338852,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_clpso_seed42_1da0611f192f",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "1da0611f192f",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ce7542b765c31886",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.5407118201255798,
+ "accuracy": 0.75,
+ "mse": 0.1815531998872757
+ },
+ "eval_metrics": {
+ "loss": 0.5407118201255798,
+ "accuracy": 0.75,
+ "mse": 0.1815531998872757
+ },
+ "runtime_seconds": 2.735748207895085,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_clpso_seed43_2589e4f53bd8",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "2589e4f53bd8",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "af36176b8ad726d5",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.5814402103424072,
+ "accuracy": 0.75,
+ "mse": 0.19513577222824097
+ },
+ "eval_metrics": {
+ "loss": 0.5814402103424072,
+ "accuracy": 0.75,
+ "mse": 0.19513577222824097
+ },
+ "runtime_seconds": 2.088508625049144,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_clpso_seed44_bbbc799fbe91",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "bbbc799fbe91",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "8e381587afeb224a",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.5649492144584656,
+ "accuracy": 0.5,
+ "mse": 0.19130167365074158
+ },
+ "eval_metrics": {
+ "loss": 0.5649492144584656,
+ "accuracy": 0.5,
+ "mse": 0.19130167365074158
+ },
+ "runtime_seconds": 2.1120476671494544,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_clpso_seed45_8ac25effcae9",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "8ac25effcae9",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "2f370bc749eaedb3",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.49745112657546997,
+ "accuracy": 0.5,
+ "mse": 0.16264399886131287
+ },
+ "eval_metrics": {
+ "loss": 0.49745112657546997,
+ "accuracy": 0.5,
+ "mse": 0.16264399886131287
+ },
+ "runtime_seconds": 2.2890608329325914,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_bare_bones_seed41_3906b134b33a",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "3906b134b33a",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ff7c5c0c14cb5935",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.08161257207393646,
+ "accuracy": 1.0,
+ "mse": 0.011008525267243385
+ },
+ "eval_metrics": {
+ "loss": 0.08161257207393646,
+ "accuracy": 1.0,
+ "mse": 0.011008525267243385
+ },
+ "runtime_seconds": 2.2026520839426666,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_bare_bones_seed42_0efa8e0d60bd",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "0efa8e0d60bd",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ce7542b765c31886",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.1651938557624817,
+ "accuracy": 1.0,
+ "mse": 0.026353763416409492
+ },
+ "eval_metrics": {
+ "loss": 0.1651938557624817,
+ "accuracy": 1.0,
+ "mse": 0.026353763416409492
+ },
+ "runtime_seconds": 2.1339512090198696,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_bare_bones_seed43_b0fa117d5fed",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "b0fa117d5fed",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "af36176b8ad726d5",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.04654743894934654,
+ "accuracy": 1.0,
+ "mse": 0.002738501410931349
+ },
+ "eval_metrics": {
+ "loss": 0.04654743894934654,
+ "accuracy": 1.0,
+ "mse": 0.002738501410931349
+ },
+ "runtime_seconds": 1.9250465838704258,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_bare_bones_seed44_accbb9791014",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "accbb9791014",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "8e381587afeb224a",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.10160364955663681,
+ "accuracy": 1.0,
+ "mse": 0.014103962108492851
+ },
+ "eval_metrics": {
+ "loss": 0.10160364955663681,
+ "accuracy": 1.0,
+ "mse": 0.014103962108492851
+ },
+ "runtime_seconds": 1.8771265409886837,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_bare_bones_seed45_f04b66649972",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f04b66649972",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "2f370bc749eaedb3",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.015541063621640205,
+ "accuracy": 1.0,
+ "mse": 0.0003285584971308708
+ },
+ "eval_metrics": {
+ "loss": 0.015541063621640205,
+ "accuracy": 1.0,
+ "mse": 0.0003285584971308708
+ },
+ "runtime_seconds": 2.0173289170488715,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_adaptive_moment_seed41_adedd2b0ac39",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "adedd2b0ac39",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ff7c5c0c14cb5935",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.022241324186325073,
+ "accuracy": 1.0,
+ "mse": 0.0006689795409329236
+ },
+ "eval_metrics": {
+ "loss": 0.022241324186325073,
+ "accuracy": 1.0,
+ "mse": 0.0006689795409329236
+ },
+ "runtime_seconds": 1.7915962911210954,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_adaptive_moment_seed42_c868ae82d08d",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "c868ae82d08d",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "ce7542b765c31886",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.19744841754436493,
+ "accuracy": 1.0,
+ "mse": 0.036092229187488556
+ },
+ "eval_metrics": {
+ "loss": 0.19744841754436493,
+ "accuracy": 1.0,
+ "mse": 0.036092229187488556
+ },
+ "runtime_seconds": 1.8184211668558419,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_adaptive_moment_seed43_2b521e2d3b7b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "2b521e2d3b7b",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "af36176b8ad726d5",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.2287585735321045,
+ "accuracy": 1.0,
+ "mse": 0.04654928296804428
+ },
+ "eval_metrics": {
+ "loss": 0.2287585735321045,
+ "accuracy": 1.0,
+ "mse": 0.04654928296804428
+ },
+ "runtime_seconds": 1.734985833056271,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_adaptive_moment_seed44_5d3d1ce1603d",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "5d3d1ce1603d",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "8e381587afeb224a",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.46346455812454224,
+ "accuracy": 1.0,
+ "mse": 0.14003631472587585
+ },
+ "eval_metrics": {
+ "loss": 0.46346455812454224,
+ "accuracy": 1.0,
+ "mse": 0.14003631472587585
+ },
+ "runtime_seconds": 1.6678355000913143,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_XOR_adaptive_moment_seed45_3b26b5258104",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "3b26b5258104",
+ "data_fingerprint": "6c1e10662699bd57",
+ "initial_model_fingerprint": "2f370bc749eaedb3",
+ "type": "main",
+ "dataset": "XOR",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "score_source": "train",
+ "model_param_count": 17,
+ "train_data_size": 4,
+ "eval_data_size": 4,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "XOR",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 1.0
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.040244005620479584,
+ "accuracy": 1.0,
+ "mse": 0.0018528070067986846
+ },
+ "eval_metrics": {
+ "loss": 0.040244005620479584,
+ "accuracy": 1.0,
+ "mse": 0.0018528070067986846
+ },
+ "runtime_seconds": 1.913532042177394,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_original_seed41_b4d02d8a912a",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "b4d02d8a912a",
+ "data_fingerprint": "a15853800414f74a",
+ "initial_model_fingerprint": "aa41c75db115931b",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "original",
+ "profile": "original",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.10860574245452881,
+ "accuracy": 0.9583333134651184,
+ "mse": 0.020560119301080704
+ },
+ "eval_metrics": {
+ "loss": 0.20332905650138855,
+ "accuracy": 0.9666666388511658,
+ "mse": 0.032227613031864166
+ },
+ "runtime_seconds": 1.4925589167978615,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_original_seed42_7b832e1502d8",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7b832e1502d8",
+ "data_fingerprint": "1e2111f4c36abf15",
+ "initial_model_fingerprint": "7ad00c2e965dca08",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "original",
+ "profile": "original",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.09278852492570877,
+ "accuracy": 0.9666666388511658,
+ "mse": 0.014507713727653027
+ },
+ "eval_metrics": {
+ "loss": 0.13762320578098297,
+ "accuracy": 0.9666666388511658,
+ "mse": 0.022901346907019615
+ },
+ "runtime_seconds": 1.524340417003259,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_original_seed43_c7a7744e07cd",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "c7a7744e07cd",
+ "data_fingerprint": "695e9332882e5fa7",
+ "initial_model_fingerprint": "96c3143c14f93c89",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "original",
+ "profile": "original",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.08031471073627472,
+ "accuracy": 0.9583333134651184,
+ "mse": 0.01690475456416607
+ },
+ "eval_metrics": {
+ "loss": 0.19265690445899963,
+ "accuracy": 0.9333333373069763,
+ "mse": 0.03963882103562355
+ },
+ "runtime_seconds": 1.5651950831525028,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_original_seed44_554a707a805b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "554a707a805b",
+ "data_fingerprint": "bacaea24358f6c07",
+ "initial_model_fingerprint": "0e5954b41e18974a",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "original",
+ "profile": "original",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.05559400096535683,
+ "accuracy": 0.9833333492279053,
+ "mse": 0.010997699573636055
+ },
+ "eval_metrics": {
+ "loss": 0.08932501822710037,
+ "accuracy": 0.9666666388511658,
+ "mse": 0.01903277263045311
+ },
+ "runtime_seconds": 1.4674046249128878,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_original_seed45_8e7f105190d0",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "8e7f105190d0",
+ "data_fingerprint": "5b7055646e5a0361",
+ "initial_model_fingerprint": "a86990b2e65a2fc7",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "original",
+ "profile": "original",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.09979524463415146,
+ "accuracy": 0.9666666388511658,
+ "mse": 0.01961543783545494
+ },
+ "eval_metrics": {
+ "loss": 0.4886879324913025,
+ "accuracy": 0.7666666507720947,
+ "mse": 0.10480202734470367
+ },
+ "runtime_seconds": 1.4620804579462856,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_inertia_seed41_ebd2c082498e",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "ebd2c082498e",
+ "data_fingerprint": "a15853800414f74a",
+ "initial_model_fingerprint": "aa41c75db115931b",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.026287496089935303,
+ "accuracy": 0.9916666746139526,
+ "mse": 0.004462411627173424
+ },
+ "eval_metrics": {
+ "loss": 0.18428005278110504,
+ "accuracy": 0.8999999761581421,
+ "mse": 0.03982445225119591
+ },
+ "runtime_seconds": 1.4285129578784108,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_inertia_seed42_afe83be466ff",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "afe83be466ff",
+ "data_fingerprint": "1e2111f4c36abf15",
+ "initial_model_fingerprint": "7ad00c2e965dca08",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.05131379887461662,
+ "accuracy": 0.9833333492279053,
+ "mse": 0.009366508573293686
+ },
+ "eval_metrics": {
+ "loss": 0.07086596637964249,
+ "accuracy": 0.9666666388511658,
+ "mse": 0.01370661798864603
+ },
+ "runtime_seconds": 1.5298712090589106,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_inertia_seed43_8535e0e82480",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "8535e0e82480",
+ "data_fingerprint": "695e9332882e5fa7",
+ "initial_model_fingerprint": "96c3143c14f93c89",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.04492912441492081,
+ "accuracy": 0.9750000238418579,
+ "mse": 0.009185881353914738
+ },
+ "eval_metrics": {
+ "loss": 0.12480489164590836,
+ "accuracy": 0.9333333373069763,
+ "mse": 0.030148915946483612
+ },
+ "runtime_seconds": 1.7474301669280976,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_inertia_seed44_8f7417014b48",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "8f7417014b48",
+ "data_fingerprint": "bacaea24358f6c07",
+ "initial_model_fingerprint": "0e5954b41e18974a",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.052643101662397385,
+ "accuracy": 0.9833333492279053,
+ "mse": 0.009580972604453564
+ },
+ "eval_metrics": {
+ "loss": 0.04644780233502388,
+ "accuracy": 0.9666666388511658,
+ "mse": 0.011100389994680882
+ },
+ "runtime_seconds": 1.623908500187099,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_inertia_seed45_2444f50eb210",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "2444f50eb210",
+ "data_fingerprint": "5b7055646e5a0361",
+ "initial_model_fingerprint": "a86990b2e65a2fc7",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.02932126447558403,
+ "accuracy": 0.9833333492279053,
+ "mse": 0.005083967465907335
+ },
+ "eval_metrics": {
+ "loss": 0.10810393840074539,
+ "accuracy": 0.9333333373069763,
+ "mse": 0.026548804715275764
+ },
+ "runtime_seconds": 1.5181218329817057,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_constriction_seed41_5ca82b45fdb5",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "5ca82b45fdb5",
+ "data_fingerprint": "a15853800414f74a",
+ "initial_model_fingerprint": "aa41c75db115931b",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.022227270528674126,
+ "accuracy": 1.0,
+ "mse": 0.0033963904716074467
+ },
+ "eval_metrics": {
+ "loss": 0.21843454241752625,
+ "accuracy": 0.8999999761581421,
+ "mse": 0.047650303691625595
+ },
+ "runtime_seconds": 1.3549595419317484,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_constriction_seed42_00baa09dc252",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "00baa09dc252",
+ "data_fingerprint": "1e2111f4c36abf15",
+ "initial_model_fingerprint": "7ad00c2e965dca08",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.03233511000871658,
+ "accuracy": 0.9916666746139526,
+ "mse": 0.005744758062064648
+ },
+ "eval_metrics": {
+ "loss": 0.14838628470897675,
+ "accuracy": 0.9666666388511658,
+ "mse": 0.02302354946732521
+ },
+ "runtime_seconds": 1.3403144169133157,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_constriction_seed43_f2570e97e0a7",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f2570e97e0a7",
+ "data_fingerprint": "695e9332882e5fa7",
+ "initial_model_fingerprint": "96c3143c14f93c89",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.021574920043349266,
+ "accuracy": 0.9916666746139526,
+ "mse": 0.0036132459063082933
+ },
+ "eval_metrics": {
+ "loss": 0.09814650565385818,
+ "accuracy": 0.9666666388511658,
+ "mse": 0.020602425560355186
+ },
+ "runtime_seconds": 1.5049964589998126,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_constriction_seed44_eccb08453c98",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "eccb08453c98",
+ "data_fingerprint": "bacaea24358f6c07",
+ "initial_model_fingerprint": "0e5954b41e18974a",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.050735700875520706,
+ "accuracy": 0.9833333492279053,
+ "mse": 0.0098448870703578
+ },
+ "eval_metrics": {
+ "loss": 0.1125202625989914,
+ "accuracy": 0.9666666388511658,
+ "mse": 0.02065414935350418
+ },
+ "runtime_seconds": 1.5035445000976324,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_constriction_seed45_50f58547f6fc",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "50f58547f6fc",
+ "data_fingerprint": "5b7055646e5a0361",
+ "initial_model_fingerprint": "a86990b2e65a2fc7",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.03670407086610794,
+ "accuracy": 0.9916666746139526,
+ "mse": 0.006487686652690172
+ },
+ "eval_metrics": {
+ "loss": 0.2814933657646179,
+ "accuracy": 0.8999999761581421,
+ "mse": 0.057036854326725006
+ },
+ "runtime_seconds": 1.450687457807362,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_fips_seed41_0cf971ae50f8",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "0cf971ae50f8",
+ "data_fingerprint": "a15853800414f74a",
+ "initial_model_fingerprint": "aa41c75db115931b",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.6161423921585083,
+ "accuracy": 0.7333333492279053,
+ "mse": 0.12119095027446747
+ },
+ "eval_metrics": {
+ "loss": 0.62589430809021,
+ "accuracy": 0.7333333492279053,
+ "mse": 0.12217403203248978
+ },
+ "runtime_seconds": 2.0091730828862637,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_fips_seed42_9e48057b0450",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "9e48057b0450",
+ "data_fingerprint": "1e2111f4c36abf15",
+ "initial_model_fingerprint": "7ad00c2e965dca08",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.4689887762069702,
+ "accuracy": 0.7833333611488342,
+ "mse": 0.0926060602068901
+ },
+ "eval_metrics": {
+ "loss": 0.514552652835846,
+ "accuracy": 0.7333333492279053,
+ "mse": 0.10551609098911285
+ },
+ "runtime_seconds": 2.031442165840417,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_fips_seed43_32bbd09f0884",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "32bbd09f0884",
+ "data_fingerprint": "695e9332882e5fa7",
+ "initial_model_fingerprint": "96c3143c14f93c89",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.6734053492546082,
+ "accuracy": 0.675000011920929,
+ "mse": 0.1274113804101944
+ },
+ "eval_metrics": {
+ "loss": 0.667880654335022,
+ "accuracy": 0.699999988079071,
+ "mse": 0.12568196654319763
+ },
+ "runtime_seconds": 1.981344207888469,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_fips_seed44_193cd55816a7",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "193cd55816a7",
+ "data_fingerprint": "bacaea24358f6c07",
+ "initial_model_fingerprint": "0e5954b41e18974a",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.5788673162460327,
+ "accuracy": 0.7416666746139526,
+ "mse": 0.11397261917591095
+ },
+ "eval_metrics": {
+ "loss": 0.5759884119033813,
+ "accuracy": 0.699999988079071,
+ "mse": 0.11304912716150284
+ },
+ "runtime_seconds": 1.99297408410348,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_fips_seed45_96ce7a348717",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "96ce7a348717",
+ "data_fingerprint": "5b7055646e5a0361",
+ "initial_model_fingerprint": "a86990b2e65a2fc7",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.6380999088287354,
+ "accuracy": 0.8999999761581421,
+ "mse": 0.12010224908590317
+ },
+ "eval_metrics": {
+ "loss": 0.6407364010810852,
+ "accuracy": 0.8333333134651184,
+ "mse": 0.1206156387925148
+ },
+ "runtime_seconds": 2.3463233751244843,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_clpso_seed41_9d3b1a601155",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "9d3b1a601155",
+ "data_fingerprint": "a15853800414f74a",
+ "initial_model_fingerprint": "aa41c75db115931b",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.3119705021381378,
+ "accuracy": 0.9083333611488342,
+ "mse": 0.05488188937306404
+ },
+ "eval_metrics": {
+ "loss": 0.3633672595024109,
+ "accuracy": 0.8999999761581421,
+ "mse": 0.06585036218166351
+ },
+ "runtime_seconds": 1.7683959589339793,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_clpso_seed42_c6bf03426022",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "c6bf03426022",
+ "data_fingerprint": "1e2111f4c36abf15",
+ "initial_model_fingerprint": "7ad00c2e965dca08",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.5033160448074341,
+ "accuracy": 0.699999988079071,
+ "mse": 0.10609932243824005
+ },
+ "eval_metrics": {
+ "loss": 0.4745965301990509,
+ "accuracy": 0.699999988079071,
+ "mse": 0.11178989708423615
+ },
+ "runtime_seconds": 1.8615282499231398,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_clpso_seed43_7351b45bbdfe",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7351b45bbdfe",
+ "data_fingerprint": "695e9332882e5fa7",
+ "initial_model_fingerprint": "96c3143c14f93c89",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.4304336607456207,
+ "accuracy": 0.800000011920929,
+ "mse": 0.08828374743461609
+ },
+ "eval_metrics": {
+ "loss": 0.42816275358200073,
+ "accuracy": 0.7666666507720947,
+ "mse": 0.08861970901489258
+ },
+ "runtime_seconds": 1.8678476670756936,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_clpso_seed44_1adf454f7131",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "1adf454f7131",
+ "data_fingerprint": "bacaea24358f6c07",
+ "initial_model_fingerprint": "0e5954b41e18974a",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.6254411935806274,
+ "accuracy": 0.699999988079071,
+ "mse": 0.1258193552494049
+ },
+ "eval_metrics": {
+ "loss": 0.4773784875869751,
+ "accuracy": 0.8333333134651184,
+ "mse": 0.09172647446393967
+ },
+ "runtime_seconds": 1.725365708116442,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_clpso_seed45_1d294e1baf5d",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "1d294e1baf5d",
+ "data_fingerprint": "5b7055646e5a0361",
+ "initial_model_fingerprint": "a86990b2e65a2fc7",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.44151026010513306,
+ "accuracy": 0.7916666865348816,
+ "mse": 0.08529050648212433
+ },
+ "eval_metrics": {
+ "loss": 0.4978446960449219,
+ "accuracy": 0.7666666507720947,
+ "mse": 0.0993356928229332
+ },
+ "runtime_seconds": 2.1001146249473095,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_bare_bones_seed41_7921bb8aaf85",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7921bb8aaf85",
+ "data_fingerprint": "a15853800414f74a",
+ "initial_model_fingerprint": "aa41c75db115931b",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.4370212256908417,
+ "accuracy": 0.824999988079071,
+ "mse": 0.08474347740411758
+ },
+ "eval_metrics": {
+ "loss": 0.44300490617752075,
+ "accuracy": 0.800000011920929,
+ "mse": 0.09044371545314789
+ },
+ "runtime_seconds": 1.8433932499028742,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_bare_bones_seed42_07744d9f0033",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "07744d9f0033",
+ "data_fingerprint": "1e2111f4c36abf15",
+ "initial_model_fingerprint": "7ad00c2e965dca08",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.33550530672073364,
+ "accuracy": 0.8500000238418579,
+ "mse": 0.0669655054807663
+ },
+ "eval_metrics": {
+ "loss": 0.36790934205055237,
+ "accuracy": 0.8333333134651184,
+ "mse": 0.07617824524641037
+ },
+ "runtime_seconds": 1.7300451670307666,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_bare_bones_seed43_7b76d3b8aac3",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7b76d3b8aac3",
+ "data_fingerprint": "695e9332882e5fa7",
+ "initial_model_fingerprint": "96c3143c14f93c89",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.25694021582603455,
+ "accuracy": 0.925000011920929,
+ "mse": 0.04399431496858597
+ },
+ "eval_metrics": {
+ "loss": 0.2524625062942505,
+ "accuracy": 0.8666666746139526,
+ "mse": 0.04397249594330788
+ },
+ "runtime_seconds": 1.7140729171223938,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_bare_bones_seed44_d368527df14d",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "d368527df14d",
+ "data_fingerprint": "bacaea24358f6c07",
+ "initial_model_fingerprint": "0e5954b41e18974a",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.28258049488067627,
+ "accuracy": 0.8916666507720947,
+ "mse": 0.05579116567969322
+ },
+ "eval_metrics": {
+ "loss": 0.2820243239402771,
+ "accuracy": 0.9333333373069763,
+ "mse": 0.049495622515678406
+ },
+ "runtime_seconds": 1.4903080409858376,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_bare_bones_seed45_82d2b0852f89",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "82d2b0852f89",
+ "data_fingerprint": "5b7055646e5a0361",
+ "initial_model_fingerprint": "a86990b2e65a2fc7",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.20035071671009064,
+ "accuracy": 0.9333333373069763,
+ "mse": 0.036052461713552475
+ },
+ "eval_metrics": {
+ "loss": 0.6835520267486572,
+ "accuracy": 0.800000011920929,
+ "mse": 0.10392136126756668
+ },
+ "runtime_seconds": 1.5446315000299364,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_adaptive_moment_seed41_7ad1dcf92ca1",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7ad1dcf92ca1",
+ "data_fingerprint": "a15853800414f74a",
+ "initial_model_fingerprint": "aa41c75db115931b",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.20063169300556183,
+ "accuracy": 0.9416666626930237,
+ "mse": 0.037772584706544876
+ },
+ "eval_metrics": {
+ "loss": 0.21173310279846191,
+ "accuracy": 0.8999999761581421,
+ "mse": 0.042588524520397186
+ },
+ "runtime_seconds": 1.389048415934667,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_adaptive_moment_seed42_d81c5b655231",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "d81c5b655231",
+ "data_fingerprint": "1e2111f4c36abf15",
+ "initial_model_fingerprint": "7ad00c2e965dca08",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.29763686656951904,
+ "accuracy": 0.8999999761581421,
+ "mse": 0.05601225048303604
+ },
+ "eval_metrics": {
+ "loss": 0.19951747357845306,
+ "accuracy": 0.9333333373069763,
+ "mse": 0.04033958911895752
+ },
+ "runtime_seconds": 1.4007256659679115,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_adaptive_moment_seed43_84ee48491859",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "84ee48491859",
+ "data_fingerprint": "695e9332882e5fa7",
+ "initial_model_fingerprint": "96c3143c14f93c89",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.25321128964424133,
+ "accuracy": 0.8999999761581421,
+ "mse": 0.05093394219875336
+ },
+ "eval_metrics": {
+ "loss": 0.36217355728149414,
+ "accuracy": 0.7666666507720947,
+ "mse": 0.08478870987892151
+ },
+ "runtime_seconds": 1.3897795830853283,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_adaptive_moment_seed44_0615beafb6e9",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "0615beafb6e9",
+ "data_fingerprint": "bacaea24358f6c07",
+ "initial_model_fingerprint": "0e5954b41e18974a",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.41196829080581665,
+ "accuracy": 0.824999988079071,
+ "mse": 0.08532779663801193
+ },
+ "eval_metrics": {
+ "loss": 0.33400872349739075,
+ "accuracy": 0.8666666746139526,
+ "mse": 0.06341322511434555
+ },
+ "runtime_seconds": 1.391351625090465,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Iris_adaptive_moment_seed45_4e1a9a5ccb65",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "4e1a9a5ccb65",
+ "data_fingerprint": "5b7055646e5a0361",
+ "initial_model_fingerprint": "a86990b2e65a2fc7",
+ "type": "main",
+ "dataset": "Iris",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 193,
+ "train_data_size": 120,
+ "eval_data_size": 30,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Iris",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.30718883872032166,
+ "accuracy": 0.8833333253860474,
+ "mse": 0.06475858390331268
+ },
+ "eval_metrics": {
+ "loss": 0.6410742998123169,
+ "accuracy": 0.7666666507720947,
+ "mse": 0.1259499192237854
+ },
+ "runtime_seconds": 1.3918780421372503,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_original_seed41_377a28a8d099",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "377a28a8d099",
+ "data_fingerprint": "7e80b753d7119015",
+ "initial_model_fingerprint": "dbefd7fe66f4c4eb",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "original",
+ "profile": "original",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.36174407601356506,
+ "accuracy": 0.8690476417541504,
+ "mse": 0.06095118075609207
+ },
+ "eval_metrics": {
+ "loss": 0.3795766234397888,
+ "accuracy": 0.8333333134651184,
+ "mse": 0.07857725024223328
+ },
+ "runtime_seconds": 1.3252154579386115,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_original_seed42_046797baed2d",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "046797baed2d",
+ "data_fingerprint": "cf020fdde139c2bd",
+ "initial_model_fingerprint": "7ed3952c2fbe78af",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "original",
+ "profile": "original",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.19747969508171082,
+ "accuracy": 0.9285714030265808,
+ "mse": 0.03284886106848717
+ },
+ "eval_metrics": {
+ "loss": 0.32495376467704773,
+ "accuracy": 0.8809523582458496,
+ "mse": 0.051455724984407425
+ },
+ "runtime_seconds": 1.3588858339935541,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_original_seed43_a7b574bbf066",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "a7b574bbf066",
+ "data_fingerprint": "47bc2f572c5fec1c",
+ "initial_model_fingerprint": "3eb1a9ef1e9335f6",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "original",
+ "profile": "original",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.18548674881458282,
+ "accuracy": 0.9404761791229248,
+ "mse": 0.029585858806967735
+ },
+ "eval_metrics": {
+ "loss": 1.2608298063278198,
+ "accuracy": 0.8333333134651184,
+ "mse": 0.10933111608028412
+ },
+ "runtime_seconds": 1.5317023331299424,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_original_seed44_bf06ec2410cc",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "bf06ec2410cc",
+ "data_fingerprint": "a1b1ab0ba50da4d9",
+ "initial_model_fingerprint": "b2ea3cb552ada071",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "original",
+ "profile": "original",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.24154052138328552,
+ "accuracy": 0.9047619104385376,
+ "mse": 0.0482390932738781
+ },
+ "eval_metrics": {
+ "loss": 0.22118255496025085,
+ "accuracy": 0.9285714030265808,
+ "mse": 0.04315038025379181
+ },
+ "runtime_seconds": 1.3482235420960933,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_original_seed45_22340e887dd8",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "22340e887dd8",
+ "data_fingerprint": "f21a5f22d78d3eb1",
+ "initial_model_fingerprint": "9e5b46ee1b7caff0",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "original",
+ "profile": "original",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.24494366347789764,
+ "accuracy": 0.9404761791229248,
+ "mse": 0.04203984886407852
+ },
+ "eval_metrics": {
+ "loss": 0.27465957403182983,
+ "accuracy": 0.9047619104385376,
+ "mse": 0.04629417136311531
+ },
+ "runtime_seconds": 1.3649861658923328,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_inertia_seed41_4738be68305f",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "4738be68305f",
+ "data_fingerprint": "7e80b753d7119015",
+ "initial_model_fingerprint": "dbefd7fe66f4c4eb",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.1457017958164215,
+ "accuracy": 0.9404761791229248,
+ "mse": 0.029012415558099747
+ },
+ "eval_metrics": {
+ "loss": 0.2021040916442871,
+ "accuracy": 0.9285714030265808,
+ "mse": 0.03903716802597046
+ },
+ "runtime_seconds": 1.3169554590713233,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_inertia_seed42_0898a41455b9",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "0898a41455b9",
+ "data_fingerprint": "cf020fdde139c2bd",
+ "initial_model_fingerprint": "7ed3952c2fbe78af",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.05112343654036522,
+ "accuracy": 0.988095223903656,
+ "mse": 0.010074331425130367
+ },
+ "eval_metrics": {
+ "loss": 0.2611672878265381,
+ "accuracy": 0.9047619104385376,
+ "mse": 0.044255580753088
+ },
+ "runtime_seconds": 1.3047084577847272,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_inertia_seed43_46f034dfbe86",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "46f034dfbe86",
+ "data_fingerprint": "47bc2f572c5fec1c",
+ "initial_model_fingerprint": "3eb1a9ef1e9335f6",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.09987328946590424,
+ "accuracy": 0.9642857313156128,
+ "mse": 0.02014271728694439
+ },
+ "eval_metrics": {
+ "loss": 0.9319664835929871,
+ "accuracy": 0.8333333134651184,
+ "mse": 0.1108398288488388
+ },
+ "runtime_seconds": 1.343342708889395,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_inertia_seed44_5891b8c668d9",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "5891b8c668d9",
+ "data_fingerprint": "a1b1ab0ba50da4d9",
+ "initial_model_fingerprint": "b2ea3cb552ada071",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.1123252734541893,
+ "accuracy": 0.9523809552192688,
+ "mse": 0.021632598713040352
+ },
+ "eval_metrics": {
+ "loss": 0.07083266228437424,
+ "accuracy": 0.976190447807312,
+ "mse": 0.014935223385691643
+ },
+ "runtime_seconds": 1.3188399588689208,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_inertia_seed45_9e1eeaa3c2aa",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "9e1eeaa3c2aa",
+ "data_fingerprint": "f21a5f22d78d3eb1",
+ "initial_model_fingerprint": "9e5b46ee1b7caff0",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.10663793236017227,
+ "accuracy": 0.9702380895614624,
+ "mse": 0.018331807106733322
+ },
+ "eval_metrics": {
+ "loss": 0.19221118092536926,
+ "accuracy": 0.9285714030265808,
+ "mse": 0.03592698276042938
+ },
+ "runtime_seconds": 1.3071315840352327,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_constriction_seed41_83e65741da8d",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "83e65741da8d",
+ "data_fingerprint": "7e80b753d7119015",
+ "initial_model_fingerprint": "dbefd7fe66f4c4eb",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.11064790189266205,
+ "accuracy": 0.9345238208770752,
+ "mse": 0.022504204884171486
+ },
+ "eval_metrics": {
+ "loss": 0.06002597510814667,
+ "accuracy": 1.0,
+ "mse": 0.006985229440033436
+ },
+ "runtime_seconds": 1.3568381250370294,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_constriction_seed42_1e7c2d96e532",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "1e7c2d96e532",
+ "data_fingerprint": "cf020fdde139c2bd",
+ "initial_model_fingerprint": "7ed3952c2fbe78af",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.05422748252749443,
+ "accuracy": 0.976190447807312,
+ "mse": 0.010376724414527416
+ },
+ "eval_metrics": {
+ "loss": 0.25236639380455017,
+ "accuracy": 0.8571428656578064,
+ "mse": 0.058809228241443634
+ },
+ "runtime_seconds": 1.4554610000923276,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_constriction_seed43_873a97b2bdfb",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "873a97b2bdfb",
+ "data_fingerprint": "47bc2f572c5fec1c",
+ "initial_model_fingerprint": "3eb1a9ef1e9335f6",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.07006674259901047,
+ "accuracy": 0.9702380895614624,
+ "mse": 0.013116533868014812
+ },
+ "eval_metrics": {
+ "loss": 1.0155233144760132,
+ "accuracy": 0.761904776096344,
+ "mse": 0.13936738669872284
+ },
+ "runtime_seconds": 1.3231734160799533,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_constriction_seed44_4a22fa9a0901",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "4a22fa9a0901",
+ "data_fingerprint": "a1b1ab0ba50da4d9",
+ "initial_model_fingerprint": "b2ea3cb552ada071",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.12728404998779297,
+ "accuracy": 0.9702380895614624,
+ "mse": 0.02088327705860138
+ },
+ "eval_metrics": {
+ "loss": 0.092940554022789,
+ "accuracy": 0.9523809552192688,
+ "mse": 0.017046619206666946
+ },
+ "runtime_seconds": 1.3528277918230742,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_constriction_seed45_e017cbd92a36",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "e017cbd92a36",
+ "data_fingerprint": "f21a5f22d78d3eb1",
+ "initial_model_fingerprint": "9e5b46ee1b7caff0",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.1418670266866684,
+ "accuracy": 0.9523809552192688,
+ "mse": 0.02600831910967827
+ },
+ "eval_metrics": {
+ "loss": 0.3362426459789276,
+ "accuracy": 0.8809523582458496,
+ "mse": 0.06100025773048401
+ },
+ "runtime_seconds": 1.3302475831005722,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_fips_seed41_ada1e8907d2f",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "ada1e8907d2f",
+ "data_fingerprint": "7e80b753d7119015",
+ "initial_model_fingerprint": "dbefd7fe66f4c4eb",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.26906877756118774,
+ "accuracy": 0.886904776096344,
+ "mse": 0.04846500605344772
+ },
+ "eval_metrics": {
+ "loss": 0.2535381317138672,
+ "accuracy": 0.9285714030265808,
+ "mse": 0.047001104801893234
+ },
+ "runtime_seconds": 1.7890820419415832,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_fips_seed42_e556df3e02b3",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "e556df3e02b3",
+ "data_fingerprint": "cf020fdde139c2bd",
+ "initial_model_fingerprint": "7ed3952c2fbe78af",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.2920786142349243,
+ "accuracy": 0.9226190447807312,
+ "mse": 0.04750432074069977
+ },
+ "eval_metrics": {
+ "loss": 0.3242204785346985,
+ "accuracy": 0.9047619104385376,
+ "mse": 0.05955858901143074
+ },
+ "runtime_seconds": 1.8719375829678029,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_fips_seed43_c4f26a818da6",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "c4f26a818da6",
+ "data_fingerprint": "47bc2f572c5fec1c",
+ "initial_model_fingerprint": "3eb1a9ef1e9335f6",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.3442629277706146,
+ "accuracy": 0.8809523582458496,
+ "mse": 0.06164747104048729
+ },
+ "eval_metrics": {
+ "loss": 0.5302116870880127,
+ "accuracy": 0.8333333134651184,
+ "mse": 0.09202633053064346
+ },
+ "runtime_seconds": 1.7939549998845905,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_fips_seed44_d1505c43c5b6",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "d1505c43c5b6",
+ "data_fingerprint": "a1b1ab0ba50da4d9",
+ "initial_model_fingerprint": "b2ea3cb552ada071",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.3943226635456085,
+ "accuracy": 0.9047619104385376,
+ "mse": 0.06531801074743271
+ },
+ "eval_metrics": {
+ "loss": 0.4183882772922516,
+ "accuracy": 0.8809523582458496,
+ "mse": 0.06837274879217148
+ },
+ "runtime_seconds": 1.7675437920261174,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_fips_seed45_dca0af39e7f3",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "dca0af39e7f3",
+ "data_fingerprint": "f21a5f22d78d3eb1",
+ "initial_model_fingerprint": "9e5b46ee1b7caff0",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.3839356601238251,
+ "accuracy": 0.9047619104385376,
+ "mse": 0.06689421087503433
+ },
+ "eval_metrics": {
+ "loss": 0.39230257272720337,
+ "accuracy": 0.8809523582458496,
+ "mse": 0.07074484974145889
+ },
+ "runtime_seconds": 1.855442832922563,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_clpso_seed41_2b83251a6646",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "2b83251a6646",
+ "data_fingerprint": "7e80b753d7119015",
+ "initial_model_fingerprint": "dbefd7fe66f4c4eb",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.35530516505241394,
+ "accuracy": 0.886904776096344,
+ "mse": 0.061445049941539764
+ },
+ "eval_metrics": {
+ "loss": 0.40069860219955444,
+ "accuracy": 0.8809523582458496,
+ "mse": 0.07505422830581665
+ },
+ "runtime_seconds": 1.5635312090162188,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_clpso_seed42_cddd7ffa6e80",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "cddd7ffa6e80",
+ "data_fingerprint": "cf020fdde139c2bd",
+ "initial_model_fingerprint": "7ed3952c2fbe78af",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.4123992919921875,
+ "accuracy": 0.8928571343421936,
+ "mse": 0.07035600394010544
+ },
+ "eval_metrics": {
+ "loss": 0.5104729533195496,
+ "accuracy": 0.8095238208770752,
+ "mse": 0.09218531101942062
+ },
+ "runtime_seconds": 1.5250467080622911,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_clpso_seed43_92b5d9490b3c",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "92b5d9490b3c",
+ "data_fingerprint": "47bc2f572c5fec1c",
+ "initial_model_fingerprint": "3eb1a9ef1e9335f6",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.3129984438419342,
+ "accuracy": 0.9226190447807312,
+ "mse": 0.053032830357551575
+ },
+ "eval_metrics": {
+ "loss": 0.5279183983802795,
+ "accuracy": 0.8809523582458496,
+ "mse": 0.08940506726503372
+ },
+ "runtime_seconds": 1.5179153748322278,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_clpso_seed44_b1857073eda8",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "b1857073eda8",
+ "data_fingerprint": "a1b1ab0ba50da4d9",
+ "initial_model_fingerprint": "b2ea3cb552ada071",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.35888010263442993,
+ "accuracy": 0.886904776096344,
+ "mse": 0.06212281435728073
+ },
+ "eval_metrics": {
+ "loss": 0.38010087609291077,
+ "accuracy": 0.8571428656578064,
+ "mse": 0.06836829334497452
+ },
+ "runtime_seconds": 1.5335276669356972,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_clpso_seed45_afc7bc0d4f65",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "afc7bc0d4f65",
+ "data_fingerprint": "f21a5f22d78d3eb1",
+ "initial_model_fingerprint": "9e5b46ee1b7caff0",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.40989989042282104,
+ "accuracy": 0.875,
+ "mse": 0.07522381842136383
+ },
+ "eval_metrics": {
+ "loss": 0.5298960208892822,
+ "accuracy": 0.8571428656578064,
+ "mse": 0.09548462182283401
+ },
+ "runtime_seconds": 1.547617708100006,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_bare_bones_seed41_7e7a2a9c407f",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7e7a2a9c407f",
+ "data_fingerprint": "7e80b753d7119015",
+ "initial_model_fingerprint": "dbefd7fe66f4c4eb",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.31048667430877686,
+ "accuracy": 0.863095223903656,
+ "mse": 0.05961725860834122
+ },
+ "eval_metrics": {
+ "loss": 0.32448282837867737,
+ "accuracy": 0.8571428656578064,
+ "mse": 0.068290114402771
+ },
+ "runtime_seconds": 1.5167391668073833,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_bare_bones_seed42_7655246be67a",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7655246be67a",
+ "data_fingerprint": "cf020fdde139c2bd",
+ "initial_model_fingerprint": "7ed3952c2fbe78af",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.3707817792892456,
+ "accuracy": 0.898809552192688,
+ "mse": 0.05272166058421135
+ },
+ "eval_metrics": {
+ "loss": 0.46162325143814087,
+ "accuracy": 0.9285714030265808,
+ "mse": 0.05430768057703972
+ },
+ "runtime_seconds": 1.5367225410882384,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_bare_bones_seed43_0012a847d23a",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "0012a847d23a",
+ "data_fingerprint": "47bc2f572c5fec1c",
+ "initial_model_fingerprint": "3eb1a9ef1e9335f6",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.3507571816444397,
+ "accuracy": 0.8928571343421936,
+ "mse": 0.052577145397663116
+ },
+ "eval_metrics": {
+ "loss": 0.592940092086792,
+ "accuracy": 0.8333333134651184,
+ "mse": 0.0866384357213974
+ },
+ "runtime_seconds": 1.5569617089349777,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_bare_bones_seed44_1e6bf73eaf1e",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "1e6bf73eaf1e",
+ "data_fingerprint": "a1b1ab0ba50da4d9",
+ "initial_model_fingerprint": "b2ea3cb552ada071",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.33141136169433594,
+ "accuracy": 0.898809552192688,
+ "mse": 0.06309879571199417
+ },
+ "eval_metrics": {
+ "loss": 0.29140159487724304,
+ "accuracy": 0.9523809552192688,
+ "mse": 0.05281345546245575
+ },
+ "runtime_seconds": 1.5635050002019852,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_bare_bones_seed45_9bf78a5325c4",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "9bf78a5325c4",
+ "data_fingerprint": "f21a5f22d78d3eb1",
+ "initial_model_fingerprint": "9e5b46ee1b7caff0",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.37824103236198425,
+ "accuracy": 0.8571428656578064,
+ "mse": 0.0701170265674591
+ },
+ "eval_metrics": {
+ "loss": 0.4391506612300873,
+ "accuracy": 0.7857142686843872,
+ "mse": 0.08444318175315857
+ },
+ "runtime_seconds": 1.534322916995734,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_adaptive_moment_seed41_65ac92a6bf33",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "65ac92a6bf33",
+ "data_fingerprint": "7e80b753d7119015",
+ "initial_model_fingerprint": "dbefd7fe66f4c4eb",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.23019717633724213,
+ "accuracy": 0.9107142686843872,
+ "mse": 0.04132877662777901
+ },
+ "eval_metrics": {
+ "loss": 0.2069307118654251,
+ "accuracy": 0.9523809552192688,
+ "mse": 0.04002527892589569
+ },
+ "runtime_seconds": 1.3558514169417322,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_adaptive_moment_seed42_41200e070b38",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "41200e070b38",
+ "data_fingerprint": "cf020fdde139c2bd",
+ "initial_model_fingerprint": "7ed3952c2fbe78af",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.21417540311813354,
+ "accuracy": 0.9226190447807312,
+ "mse": 0.03754362091422081
+ },
+ "eval_metrics": {
+ "loss": 0.24953606724739075,
+ "accuracy": 0.9047619104385376,
+ "mse": 0.050037819892168045
+ },
+ "runtime_seconds": 1.3875930421054363,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_adaptive_moment_seed43_7f32e3655d1d",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7f32e3655d1d",
+ "data_fingerprint": "47bc2f572c5fec1c",
+ "initial_model_fingerprint": "3eb1a9ef1e9335f6",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.22975336015224457,
+ "accuracy": 0.9166666865348816,
+ "mse": 0.04079404100775719
+ },
+ "eval_metrics": {
+ "loss": 0.517500638961792,
+ "accuracy": 0.8333333134651184,
+ "mse": 0.06756050139665604
+ },
+ "runtime_seconds": 1.3970742078963667,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_adaptive_moment_seed44_c35522f27323",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "c35522f27323",
+ "data_fingerprint": "a1b1ab0ba50da4d9",
+ "initial_model_fingerprint": "b2ea3cb552ada071",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.17773085832595825,
+ "accuracy": 0.9285714030265808,
+ "mse": 0.0371076837182045
+ },
+ "eval_metrics": {
+ "loss": 0.2783668041229248,
+ "accuracy": 0.9047619104385376,
+ "mse": 0.04379665106534958
+ },
+ "runtime_seconds": 1.4338162089698017,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Seeds_adaptive_moment_seed45_bf74f66d9604",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "bf74f66d9604",
+ "data_fingerprint": "f21a5f22d78d3eb1",
+ "initial_model_fingerprint": "9e5b46ee1b7caff0",
+ "type": "main",
+ "dataset": "Seeds",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "score_source": "held_out",
+ "model_param_count": 771,
+ "train_data_size": 168,
+ "eval_data_size": 42,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Seeds",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.5
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.2740238308906555,
+ "accuracy": 0.9107142686843872,
+ "mse": 0.04443332180380821
+ },
+ "eval_metrics": {
+ "loss": 0.32740139961242676,
+ "accuracy": 0.8571428656578064,
+ "mse": 0.06444984674453735
+ },
+ "runtime_seconds": 1.4622948339674622,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_original_seed41_9e81630deded",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "9e81630deded",
+ "data_fingerprint": "f0c1eef6d3164fc4",
+ "initial_model_fingerprint": "9af4896a7a2c4c81",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "original",
+ "profile": "original",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.2617411613464355,
+ "accuracy": 0.22300000488758087,
+ "mse": 0.088669553399086
+ },
+ "eval_metrics": {
+ "loss": 2.2829415798187256,
+ "accuracy": 0.1944444477558136,
+ "mse": 0.08924634754657745
+ },
+ "runtime_seconds": 2.1861627500038594,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_original_seed42_46d8c4455960",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "46d8c4455960",
+ "data_fingerprint": "f6de4fe22b228027",
+ "initial_model_fingerprint": "bf45591dfb652c19",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "original",
+ "profile": "original",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.324465751647949,
+ "accuracy": 0.16599999368190765,
+ "mse": 0.08990947902202606
+ },
+ "eval_metrics": {
+ "loss": 2.3081114292144775,
+ "accuracy": 0.14444445073604584,
+ "mse": 0.08985483646392822
+ },
+ "runtime_seconds": 2.167289041914046,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_original_seed43_4f8d65ea6120",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "4f8d65ea6120",
+ "data_fingerprint": "f617cbf50dc6fbd0",
+ "initial_model_fingerprint": "280c038c92ad7d69",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "original",
+ "profile": "original",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.2402591705322266,
+ "accuracy": 0.17900000512599945,
+ "mse": 0.08884875476360321
+ },
+ "eval_metrics": {
+ "loss": 2.2550830841064453,
+ "accuracy": 0.1805555522441864,
+ "mse": 0.08945893496274948
+ },
+ "runtime_seconds": 2.444736792007461,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_original_seed44_294c97c34039",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "294c97c34039",
+ "data_fingerprint": "39a13ea24f7fe3d3",
+ "initial_model_fingerprint": "ed364a9b2281fac5",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "original",
+ "profile": "original",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.2890374660491943,
+ "accuracy": 0.16300000250339508,
+ "mse": 0.08958756923675537
+ },
+ "eval_metrics": {
+ "loss": 2.249772071838379,
+ "accuracy": 0.14444445073604584,
+ "mse": 0.09001036733388901
+ },
+ "runtime_seconds": 2.2415781249292195,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_original_seed45_062f764d4480",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "062f764d4480",
+ "data_fingerprint": "9d5639d80ac523a9",
+ "initial_model_fingerprint": "5f1617fc58fac335",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "original",
+ "profile": "original",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.215007781982422,
+ "accuracy": 0.1679999977350235,
+ "mse": 0.0882057324051857
+ },
+ "eval_metrics": {
+ "loss": 2.252229928970337,
+ "accuracy": 0.15833333134651184,
+ "mse": 0.0888998880982399
+ },
+ "runtime_seconds": 2.321851125219837,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_inertia_seed41_daec82326233",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "daec82326233",
+ "data_fingerprint": "f0c1eef6d3164fc4",
+ "initial_model_fingerprint": "9af4896a7a2c4c81",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.173959732055664,
+ "accuracy": 0.2720000147819519,
+ "mse": 0.08434547483921051
+ },
+ "eval_metrics": {
+ "loss": 2.1810758113861084,
+ "accuracy": 0.25833332538604736,
+ "mse": 0.08479094505310059
+ },
+ "runtime_seconds": 1.9404035829938948,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_inertia_seed42_27181b02d4cd",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "27181b02d4cd",
+ "data_fingerprint": "f6de4fe22b228027",
+ "initial_model_fingerprint": "bf45591dfb652c19",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.035007953643799,
+ "accuracy": 0.28999999165534973,
+ "mse": 0.08113866299390793
+ },
+ "eval_metrics": {
+ "loss": 1.9564385414123535,
+ "accuracy": 0.3055555522441864,
+ "mse": 0.07970407605171204
+ },
+ "runtime_seconds": 1.9198420830070972,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_inertia_seed43_27938492b559",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "27938492b559",
+ "data_fingerprint": "f617cbf50dc6fbd0",
+ "initial_model_fingerprint": "280c038c92ad7d69",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.8432661294937134,
+ "accuracy": 0.35499998927116394,
+ "mse": 0.07747028768062592
+ },
+ "eval_metrics": {
+ "loss": 1.8053909540176392,
+ "accuracy": 0.3777777850627899,
+ "mse": 0.07513056695461273
+ },
+ "runtime_seconds": 1.9688580001238734,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_inertia_seed44_58a34c628d9a",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "58a34c628d9a",
+ "data_fingerprint": "39a13ea24f7fe3d3",
+ "initial_model_fingerprint": "ed364a9b2281fac5",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.114971399307251,
+ "accuracy": 0.2280000001192093,
+ "mse": 0.08531089872121811
+ },
+ "eval_metrics": {
+ "loss": 2.0523359775543213,
+ "accuracy": 0.22777777910232544,
+ "mse": 0.08450954407453537
+ },
+ "runtime_seconds": 2.044121792074293,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_inertia_seed45_c0086309a86b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "c0086309a86b",
+ "data_fingerprint": "9d5639d80ac523a9",
+ "initial_model_fingerprint": "5f1617fc58fac335",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.9059537649154663,
+ "accuracy": 0.3400000035762787,
+ "mse": 0.08020355552434921
+ },
+ "eval_metrics": {
+ "loss": 1.9080941677093506,
+ "accuracy": 0.3472222089767456,
+ "mse": 0.07944019138813019
+ },
+ "runtime_seconds": 2.161027291091159,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_constriction_seed41_e7ffbe8ff230",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "e7ffbe8ff230",
+ "data_fingerprint": "f0c1eef6d3164fc4",
+ "initial_model_fingerprint": "9af4896a7a2c4c81",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.8068615198135376,
+ "accuracy": 0.3919999897480011,
+ "mse": 0.07423090934753418
+ },
+ "eval_metrics": {
+ "loss": 1.830819010734558,
+ "accuracy": 0.3472222089767456,
+ "mse": 0.07658052444458008
+ },
+ "runtime_seconds": 2.100981292081997,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_constriction_seed42_c610271fc102",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "c610271fc102",
+ "data_fingerprint": "f6de4fe22b228027",
+ "initial_model_fingerprint": "bf45591dfb652c19",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.691806435585022,
+ "accuracy": 0.4090000092983246,
+ "mse": 0.07066111266613007
+ },
+ "eval_metrics": {
+ "loss": 1.6854695081710815,
+ "accuracy": 0.3888888955116272,
+ "mse": 0.07275129854679108
+ },
+ "runtime_seconds": 2.2917967499233782,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_constriction_seed43_cf787d661b4a",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "cf787d661b4a",
+ "data_fingerprint": "f617cbf50dc6fbd0",
+ "initial_model_fingerprint": "280c038c92ad7d69",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.661444902420044,
+ "accuracy": 0.4059999883174896,
+ "mse": 0.07141976803541183
+ },
+ "eval_metrics": {
+ "loss": 1.760801076889038,
+ "accuracy": 0.38055557012557983,
+ "mse": 0.07476656138896942
+ },
+ "runtime_seconds": 2.375207500066608,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_constriction_seed44_ec7fa365faab",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "ec7fa365faab",
+ "data_fingerprint": "39a13ea24f7fe3d3",
+ "initial_model_fingerprint": "ed364a9b2281fac5",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.7786259651184082,
+ "accuracy": 0.34200000762939453,
+ "mse": 0.07684328407049179
+ },
+ "eval_metrics": {
+ "loss": 1.7403881549835205,
+ "accuracy": 0.3611111044883728,
+ "mse": 0.07619272172451019
+ },
+ "runtime_seconds": 2.504296417115256,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_constriction_seed45_3dc815d9fb31",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "3dc815d9fb31",
+ "data_fingerprint": "9d5639d80ac523a9",
+ "initial_model_fingerprint": "5f1617fc58fac335",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.6648540496826172,
+ "accuracy": 0.3610000014305115,
+ "mse": 0.07508069276809692
+ },
+ "eval_metrics": {
+ "loss": 1.8080878257751465,
+ "accuracy": 0.3861111104488373,
+ "mse": 0.07378461956977844
+ },
+ "runtime_seconds": 2.3777815841604024,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_fips_seed41_904d32b16663",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "904d32b16663",
+ "data_fingerprint": "f0c1eef6d3164fc4",
+ "initial_model_fingerprint": "9af4896a7a2c4c81",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.0772244930267334,
+ "accuracy": 0.2160000056028366,
+ "mse": 0.08328772336244583
+ },
+ "eval_metrics": {
+ "loss": 2.0640549659729004,
+ "accuracy": 0.22499999403953552,
+ "mse": 0.08292558789253235
+ },
+ "runtime_seconds": 2.599182124948129,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_fips_seed42_7b1c76516c0b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7b1c76516c0b",
+ "data_fingerprint": "f6de4fe22b228027",
+ "initial_model_fingerprint": "bf45591dfb652c19",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.0291080474853516,
+ "accuracy": 0.19699999690055847,
+ "mse": 0.08490344136953354
+ },
+ "eval_metrics": {
+ "loss": 2.0000698566436768,
+ "accuracy": 0.15555556118488312,
+ "mse": 0.08459118753671646
+ },
+ "runtime_seconds": 2.654482499929145,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_fips_seed43_e5ff6146ad8f",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "e5ff6146ad8f",
+ "data_fingerprint": "f617cbf50dc6fbd0",
+ "initial_model_fingerprint": "280c038c92ad7d69",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.1521434783935547,
+ "accuracy": 0.2840000092983246,
+ "mse": 0.08669741451740265
+ },
+ "eval_metrics": {
+ "loss": 2.1906869411468506,
+ "accuracy": 0.2638888955116272,
+ "mse": 0.08742034435272217
+ },
+ "runtime_seconds": 2.7839837500359863,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_fips_seed44_bad6731441e0",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "bad6731441e0",
+ "data_fingerprint": "39a13ea24f7fe3d3",
+ "initial_model_fingerprint": "ed364a9b2281fac5",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.0534286499023438,
+ "accuracy": 0.3310000002384186,
+ "mse": 0.08358488231897354
+ },
+ "eval_metrics": {
+ "loss": 2.108774423599243,
+ "accuracy": 0.2944444417953491,
+ "mse": 0.0848330482840538
+ },
+ "runtime_seconds": 2.634472999954596,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_fips_seed45_655330fc9fc3",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "655330fc9fc3",
+ "data_fingerprint": "9d5639d80ac523a9",
+ "initial_model_fingerprint": "5f1617fc58fac335",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.9725496768951416,
+ "accuracy": 0.30300000309944153,
+ "mse": 0.08112427592277527
+ },
+ "eval_metrics": {
+ "loss": 1.9572372436523438,
+ "accuracy": 0.3083333373069763,
+ "mse": 0.08043570816516876
+ },
+ "runtime_seconds": 2.4333895419258624,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_clpso_seed41_0cbb1d9aebf7",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "0cbb1d9aebf7",
+ "data_fingerprint": "f0c1eef6d3164fc4",
+ "initial_model_fingerprint": "9af4896a7a2c4c81",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.1367292404174805,
+ "accuracy": 0.22599999606609344,
+ "mse": 0.08658362925052643
+ },
+ "eval_metrics": {
+ "loss": 2.1658363342285156,
+ "accuracy": 0.21388888359069824,
+ "mse": 0.08725804090499878
+ },
+ "runtime_seconds": 2.3339792501647025,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_clpso_seed42_f67db481a996",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f67db481a996",
+ "data_fingerprint": "f6de4fe22b228027",
+ "initial_model_fingerprint": "bf45591dfb652c19",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.206430196762085,
+ "accuracy": 0.21799999475479126,
+ "mse": 0.0870317742228508
+ },
+ "eval_metrics": {
+ "loss": 2.2051308155059814,
+ "accuracy": 0.19166666269302368,
+ "mse": 0.08755485713481903
+ },
+ "runtime_seconds": 2.377047209069133,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_clpso_seed43_de2363a3f338",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "de2363a3f338",
+ "data_fingerprint": "f617cbf50dc6fbd0",
+ "initial_model_fingerprint": "280c038c92ad7d69",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.201568365097046,
+ "accuracy": 0.15299999713897705,
+ "mse": 0.0885072648525238
+ },
+ "eval_metrics": {
+ "loss": 2.2101080417633057,
+ "accuracy": 0.13055555522441864,
+ "mse": 0.0891144722700119
+ },
+ "runtime_seconds": 2.3552857080940157,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_clpso_seed44_99956db6e052",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "99956db6e052",
+ "data_fingerprint": "39a13ea24f7fe3d3",
+ "initial_model_fingerprint": "ed364a9b2281fac5",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.2019567489624023,
+ "accuracy": 0.22200000286102295,
+ "mse": 0.08723719418048859
+ },
+ "eval_metrics": {
+ "loss": 2.213874101638794,
+ "accuracy": 0.24166665971279144,
+ "mse": 0.08781173825263977
+ },
+ "runtime_seconds": 2.4299692499917,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_clpso_seed45_40ab922ccd40",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "40ab922ccd40",
+ "data_fingerprint": "9d5639d80ac523a9",
+ "initial_model_fingerprint": "5f1617fc58fac335",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.135824203491211,
+ "accuracy": 0.29600000381469727,
+ "mse": 0.08445338159799576
+ },
+ "eval_metrics": {
+ "loss": 2.2277636528015137,
+ "accuracy": 0.2611111104488373,
+ "mse": 0.08523893356323242
+ },
+ "runtime_seconds": 3.1002987078391016,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_bare_bones_seed41_2802f651b43d",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "2802f651b43d",
+ "data_fingerprint": "f0c1eef6d3164fc4",
+ "initial_model_fingerprint": "9af4896a7a2c4c81",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.252967357635498,
+ "accuracy": 0.23000000417232513,
+ "mse": 0.08590874075889587
+ },
+ "eval_metrics": {
+ "loss": 2.2463696002960205,
+ "accuracy": 0.2527777850627899,
+ "mse": 0.0852879211306572
+ },
+ "runtime_seconds": 2.3899612920358777,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_bare_bones_seed42_b02a2be14360",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "b02a2be14360",
+ "data_fingerprint": "f6de4fe22b228027",
+ "initial_model_fingerprint": "bf45591dfb652c19",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.229649543762207,
+ "accuracy": 0.19099999964237213,
+ "mse": 0.08928735554218292
+ },
+ "eval_metrics": {
+ "loss": 2.361936569213867,
+ "accuracy": 0.14166666567325592,
+ "mse": 0.0929383784532547
+ },
+ "runtime_seconds": 2.517781083006412,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_bare_bones_seed43_b98ee4548be6",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "b98ee4548be6",
+ "data_fingerprint": "f617cbf50dc6fbd0",
+ "initial_model_fingerprint": "280c038c92ad7d69",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.1584651470184326,
+ "accuracy": 0.2460000067949295,
+ "mse": 0.08629835397005081
+ },
+ "eval_metrics": {
+ "loss": 2.124666452407837,
+ "accuracy": 0.25,
+ "mse": 0.08588261157274246
+ },
+ "runtime_seconds": 2.5478430408984423,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_bare_bones_seed44_67db3b615399",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "67db3b615399",
+ "data_fingerprint": "39a13ea24f7fe3d3",
+ "initial_model_fingerprint": "ed364a9b2281fac5",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.2550888061523438,
+ "accuracy": 0.17900000512599945,
+ "mse": 0.08894563466310501
+ },
+ "eval_metrics": {
+ "loss": 2.266505479812622,
+ "accuracy": 0.15555556118488312,
+ "mse": 0.08891921490430832
+ },
+ "runtime_seconds": 2.680936082964763,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_bare_bones_seed45_7b2a747ad3bc",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7b2a747ad3bc",
+ "data_fingerprint": "9d5639d80ac523a9",
+ "initial_model_fingerprint": "5f1617fc58fac335",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.2584753036499023,
+ "accuracy": 0.15399999916553497,
+ "mse": 0.08958878368139267
+ },
+ "eval_metrics": {
+ "loss": 2.2515347003936768,
+ "accuracy": 0.15000000596046448,
+ "mse": 0.09008078277111053
+ },
+ "runtime_seconds": 2.687859124969691,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_adaptive_moment_seed41_e74144daa637",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "e74144daa637",
+ "data_fingerprint": "f0c1eef6d3164fc4",
+ "initial_model_fingerprint": "9af4896a7a2c4c81",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 41,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.1329033374786377,
+ "accuracy": 0.2849999964237213,
+ "mse": 0.08403640985488892
+ },
+ "eval_metrics": {
+ "loss": 2.1274328231811523,
+ "accuracy": 0.28333333134651184,
+ "mse": 0.08371066302061081
+ },
+ "runtime_seconds": 2.5720566669479012,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_adaptive_moment_seed42_a2da72677525",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "a2da72677525",
+ "data_fingerprint": "f6de4fe22b228027",
+ "initial_model_fingerprint": "bf45591dfb652c19",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 42,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.0686817169189453,
+ "accuracy": 0.2709999978542328,
+ "mse": 0.08360999077558517
+ },
+ "eval_metrics": {
+ "loss": 2.0876049995422363,
+ "accuracy": 0.27222222089767456,
+ "mse": 0.08446487039327621
+ },
+ "runtime_seconds": 2.6077378750778735,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_adaptive_moment_seed43_e2d2423853ce",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "e2d2423853ce",
+ "data_fingerprint": "f617cbf50dc6fbd0",
+ "initial_model_fingerprint": "280c038c92ad7d69",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 43,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.079728126525879,
+ "accuracy": 0.2370000034570694,
+ "mse": 0.08583791553974152
+ },
+ "eval_metrics": {
+ "loss": 2.1019599437713623,
+ "accuracy": 0.2361111044883728,
+ "mse": 0.08700509369373322
+ },
+ "runtime_seconds": 2.599350499920547,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_adaptive_moment_seed44_0c440537dd5b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "0c440537dd5b",
+ "data_fingerprint": "39a13ea24f7fe3d3",
+ "initial_model_fingerprint": "ed364a9b2281fac5",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 44,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.125084161758423,
+ "accuracy": 0.257999986410141,
+ "mse": 0.0819929987192154
+ },
+ "eval_metrics": {
+ "loss": 2.1390206813812256,
+ "accuracy": 0.2750000059604645,
+ "mse": 0.08342760056257248
+ },
+ "runtime_seconds": 2.4962192920502275,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_Digits_adaptive_moment_seed45_01fad7cfff24",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "01fad7cfff24",
+ "data_fingerprint": "9d5639d80ac523a9",
+ "initial_model_fingerprint": "5f1617fc58fac335",
+ "type": "main",
+ "dataset": "Digits",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "score_source": "held_out",
+ "model_param_count": 1020,
+ "train_data_size": 1437,
+ "eval_data_size": 360,
+ "configured_pca_choice": null,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "Digits",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 45,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.25
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 1000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.0284130573272705,
+ "accuracy": 0.30799999833106995,
+ "mse": 0.07994092255830765
+ },
+ "eval_metrics": {
+ "loss": 2.088167905807495,
+ "accuracy": 0.27222222089767456,
+ "mse": 0.08149543404579163
+ },
+ "runtime_seconds": 2.2218740829266608,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_original_seed41_10d8dcb386e9",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "10d8dcb386e9",
+ "data_fingerprint": "9cf90687f18f6867",
+ "initial_model_fingerprint": "a265005eab7305ab",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "original",
+ "profile": "original",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.3936545848846436,
+ "accuracy": 0.1340000033378601,
+ "mse": 0.09311683475971222
+ },
+ "eval_metrics": {
+ "loss": 2.360574245452881,
+ "accuracy": 0.16500000655651093,
+ "mse": 0.09202645719051361
+ },
+ "runtime_seconds": 2.7690670411102474,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_original_seed42_e89647788bfa",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "e89647788bfa",
+ "data_fingerprint": "dfe645918ece54c0",
+ "initial_model_fingerprint": "f15e396114108c51",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "original",
+ "profile": "original",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.347860097885132,
+ "accuracy": 0.13899999856948853,
+ "mse": 0.09062287956476212
+ },
+ "eval_metrics": {
+ "loss": 2.3212592601776123,
+ "accuracy": 0.14300000667572021,
+ "mse": 0.09031510353088379
+ },
+ "runtime_seconds": 3.077394332969561,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_original_seed43_ea229e5a7257",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "ea229e5a7257",
+ "data_fingerprint": "730cd610fc573af5",
+ "initial_model_fingerprint": "d9abe6f36969a8b5",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "original",
+ "profile": "original",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.4784181118011475,
+ "accuracy": 0.15700000524520874,
+ "mse": 0.09438490122556686
+ },
+ "eval_metrics": {
+ "loss": 2.5147814750671387,
+ "accuracy": 0.15600000321865082,
+ "mse": 0.09482964128255844
+ },
+ "runtime_seconds": 4.626529292203486,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_original_seed44_23051c2e549b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "23051c2e549b",
+ "data_fingerprint": "718e473f23ab68a4",
+ "initial_model_fingerprint": "497c2208b39cbf7e",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "original",
+ "profile": "original",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.30441951751709,
+ "accuracy": 0.17550000548362732,
+ "mse": 0.09123670309782028
+ },
+ "eval_metrics": {
+ "loss": 2.415644645690918,
+ "accuracy": 0.12600000202655792,
+ "mse": 0.09450323134660721
+ },
+ "runtime_seconds": 2.7831446670461446,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_original_seed45_ef2c6b1b100c",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "ef2c6b1b100c",
+ "data_fingerprint": "28844e0cd0f7c25c",
+ "initial_model_fingerprint": "cbffa45f13f8dead",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "original",
+ "profile": "original",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "original",
+ "profile": "original",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Original PSO",
+ "source": "10.1109/ICNN.1995.488968",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.4028897285461426,
+ "accuracy": 0.17599999904632568,
+ "mse": 0.09126102179288864
+ },
+ "eval_metrics": {
+ "loss": 2.528709888458252,
+ "accuracy": 0.12999999523162842,
+ "mse": 0.09350301325321198
+ },
+ "runtime_seconds": 4.194451209157705,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_inertia_seed41_641c37d1902c",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "641c37d1902c",
+ "data_fingerprint": "9cf90687f18f6867",
+ "initial_model_fingerprint": "a265005eab7305ab",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.3381215333938599,
+ "accuracy": 0.5924999713897705,
+ "mse": 0.056777868419885635
+ },
+ "eval_metrics": {
+ "loss": 1.5549514293670654,
+ "accuracy": 0.5210000276565552,
+ "mse": 0.06475670635700226
+ },
+ "runtime_seconds": 2.9916708329692483,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_inertia_seed42_3d723b7c453e",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "3d723b7c453e",
+ "data_fingerprint": "dfe645918ece54c0",
+ "initial_model_fingerprint": "f15e396114108c51",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.4281961917877197,
+ "accuracy": 0.5634999871253967,
+ "mse": 0.059982724487781525
+ },
+ "eval_metrics": {
+ "loss": 1.6201825141906738,
+ "accuracy": 0.4970000088214874,
+ "mse": 0.06761188060045242
+ },
+ "runtime_seconds": 2.965985749848187,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_inertia_seed43_6dfb0d0fd6ae",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "6dfb0d0fd6ae",
+ "data_fingerprint": "730cd610fc573af5",
+ "initial_model_fingerprint": "d9abe6f36969a8b5",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.6584088802337646,
+ "accuracy": 0.4749999940395355,
+ "mse": 0.06921082735061646
+ },
+ "eval_metrics": {
+ "loss": 2.078524112701416,
+ "accuracy": 0.367000013589859,
+ "mse": 0.08277533203363419
+ },
+ "runtime_seconds": 2.8704891668166965,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_inertia_seed44_c84bb533c9b4",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "c84bb533c9b4",
+ "data_fingerprint": "718e473f23ab68a4",
+ "initial_model_fingerprint": "497c2208b39cbf7e",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.2869731187820435,
+ "accuracy": 0.6085000038146973,
+ "mse": 0.054680656641721725
+ },
+ "eval_metrics": {
+ "loss": 1.4398808479309082,
+ "accuracy": 0.5440000295639038,
+ "mse": 0.062213294208049774
+ },
+ "runtime_seconds": 3.254134749993682,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_inertia_seed45_aa08e9112815",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "aa08e9112815",
+ "data_fingerprint": "28844e0cd0f7c25c",
+ "initial_model_fingerprint": "cbffa45f13f8dead",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "inertia",
+ "profile": "inertia",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.5111486911773682,
+ "accuracy": 0.5205000042915344,
+ "mse": 0.06331299990415573
+ },
+ "eval_metrics": {
+ "loss": 1.8869050741195679,
+ "accuracy": 0.4129999876022339,
+ "mse": 0.07616910338401794
+ },
+ "runtime_seconds": 3.160143041983247,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_constriction_seed41_5282d73f094b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "5282d73f094b",
+ "data_fingerprint": "9cf90687f18f6867",
+ "initial_model_fingerprint": "a265005eab7305ab",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.386448860168457,
+ "accuracy": 0.5584999918937683,
+ "mse": 0.05983114242553711
+ },
+ "eval_metrics": {
+ "loss": 1.569274663925171,
+ "accuracy": 0.4909999966621399,
+ "mse": 0.06642866879701614
+ },
+ "runtime_seconds": 3.0594240000937134,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_constriction_seed42_bb70d1d70037",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "bb70d1d70037",
+ "data_fingerprint": "dfe645918ece54c0",
+ "initial_model_fingerprint": "f15e396114108c51",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.1828755140304565,
+ "accuracy": 0.6234999895095825,
+ "mse": 0.05046923831105232
+ },
+ "eval_metrics": {
+ "loss": 1.2963975667953491,
+ "accuracy": 0.5820000171661377,
+ "mse": 0.055818524211645126
+ },
+ "runtime_seconds": 3.015819540945813,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_constriction_seed43_97cc6fb1fe0a",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "97cc6fb1fe0a",
+ "data_fingerprint": "730cd610fc573af5",
+ "initial_model_fingerprint": "d9abe6f36969a8b5",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.3433197736740112,
+ "accuracy": 0.5789999961853027,
+ "mse": 0.057317327708005905
+ },
+ "eval_metrics": {
+ "loss": 1.509533166885376,
+ "accuracy": 0.527999997138977,
+ "mse": 0.06237608194351196
+ },
+ "runtime_seconds": 3.085574916098267,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_constriction_seed44_d7ce4c4cfe42",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "d7ce4c4cfe42",
+ "data_fingerprint": "718e473f23ab68a4",
+ "initial_model_fingerprint": "497c2208b39cbf7e",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.1404569149017334,
+ "accuracy": 0.6510000228881836,
+ "mse": 0.048903413116931915
+ },
+ "eval_metrics": {
+ "loss": 1.4610586166381836,
+ "accuracy": 0.5379999876022339,
+ "mse": 0.061730675399303436
+ },
+ "runtime_seconds": 2.979554875055328,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_constriction_seed45_863470bda3e7",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "863470bda3e7",
+ "data_fingerprint": "28844e0cd0f7c25c",
+ "initial_model_fingerprint": "cbffa45f13f8dead",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "constriction",
+ "profile": "constriction",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.3689371347427368,
+ "accuracy": 0.5720000267028809,
+ "mse": 0.057907942682504654
+ },
+ "eval_metrics": {
+ "loss": 1.703574538230896,
+ "accuracy": 0.460999995470047,
+ "mse": 0.07028073072433472
+ },
+ "runtime_seconds": 4.3501843749545515,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_fips_seed41_e8949a554db5",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "e8949a554db5",
+ "data_fingerprint": "9cf90687f18f6867",
+ "initial_model_fingerprint": "a265005eab7305ab",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.300412654876709,
+ "accuracy": 0.1525000035762787,
+ "mse": 0.09028158336877823
+ },
+ "eval_metrics": {
+ "loss": 2.302541494369507,
+ "accuracy": 0.13300000131130219,
+ "mse": 0.0902903825044632
+ },
+ "runtime_seconds": 3.7603835419286042,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_fips_seed42_49c5a544efba",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "49c5a544efba",
+ "data_fingerprint": "dfe645918ece54c0",
+ "initial_model_fingerprint": "f15e396114108c51",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.140425682067871,
+ "accuracy": 0.22499999403953552,
+ "mse": 0.08616895228624344
+ },
+ "eval_metrics": {
+ "loss": 2.1612672805786133,
+ "accuracy": 0.2290000021457672,
+ "mse": 0.08728907257318497
+ },
+ "runtime_seconds": 3.8516692500561476,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_fips_seed43_9692cb7f9831",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "9692cb7f9831",
+ "data_fingerprint": "730cd610fc573af5",
+ "initial_model_fingerprint": "d9abe6f36969a8b5",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.2012534141540527,
+ "accuracy": 0.22050000727176666,
+ "mse": 0.087419293820858
+ },
+ "eval_metrics": {
+ "loss": 2.176907777786255,
+ "accuracy": 0.23800000548362732,
+ "mse": 0.08697457611560822
+ },
+ "runtime_seconds": 4.031099959043786,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_fips_seed44_f7d20d03d1c1",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f7d20d03d1c1",
+ "data_fingerprint": "718e473f23ab68a4",
+ "initial_model_fingerprint": "497c2208b39cbf7e",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.045689582824707,
+ "accuracy": 0.31450000405311584,
+ "mse": 0.08356857299804688
+ },
+ "eval_metrics": {
+ "loss": 2.17195725440979,
+ "accuracy": 0.2549999952316284,
+ "mse": 0.08656814694404602
+ },
+ "runtime_seconds": 3.694581290939823,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_fips_seed45_0095144ac727",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "0095144ac727",
+ "data_fingerprint": "28844e0cd0f7c25c",
+ "initial_model_fingerprint": "cbffa45f13f8dead",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "fips",
+ "profile": "fips",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Fully Informed Particle Swarm (FIPS)",
+ "source": "10.1109/TEVC.2004.826074",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "phi": 4.1,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.2005927562713623,
+ "accuracy": 0.23849999904632568,
+ "mse": 0.08714449405670166
+ },
+ "eval_metrics": {
+ "loss": 2.3034777641296387,
+ "accuracy": 0.1979999989271164,
+ "mse": 0.08890986442565918
+ },
+ "runtime_seconds": 3.695122124860063,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_clpso_seed41_25b503233345",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "25b503233345",
+ "data_fingerprint": "9cf90687f18f6867",
+ "initial_model_fingerprint": "a265005eab7305ab",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.2500364780426025,
+ "accuracy": 0.2094999998807907,
+ "mse": 0.08816687017679214
+ },
+ "eval_metrics": {
+ "loss": 2.316762685775757,
+ "accuracy": 0.20900000631809235,
+ "mse": 0.08957167714834213
+ },
+ "runtime_seconds": 3.9107722910121083,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_clpso_seed42_e6de3bc33ad6",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "e6de3bc33ad6",
+ "data_fingerprint": "dfe645918ece54c0",
+ "initial_model_fingerprint": "f15e396114108c51",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.0957834720611572,
+ "accuracy": 0.2524999976158142,
+ "mse": 0.08504028618335724
+ },
+ "eval_metrics": {
+ "loss": 2.172976493835449,
+ "accuracy": 0.24500000476837158,
+ "mse": 0.08746129274368286
+ },
+ "runtime_seconds": 3.3184274171944708,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_clpso_seed43_8a46f64639de",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "8a46f64639de",
+ "data_fingerprint": "730cd610fc573af5",
+ "initial_model_fingerprint": "d9abe6f36969a8b5",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.324615716934204,
+ "accuracy": 0.19949999451637268,
+ "mse": 0.0908694639801979
+ },
+ "eval_metrics": {
+ "loss": 2.352043390274048,
+ "accuracy": 0.1899999976158142,
+ "mse": 0.09161917865276337
+ },
+ "runtime_seconds": 3.5417710000183433,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_clpso_seed44_7593eb953b13",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7593eb953b13",
+ "data_fingerprint": "718e473f23ab68a4",
+ "initial_model_fingerprint": "497c2208b39cbf7e",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.17220139503479,
+ "accuracy": 0.2460000067949295,
+ "mse": 0.08573407679796219
+ },
+ "eval_metrics": {
+ "loss": 2.279698133468628,
+ "accuracy": 0.20000000298023224,
+ "mse": 0.08846663683652878
+ },
+ "runtime_seconds": 3.4085127080325037,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_clpso_seed45_3639628f38f4",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "3639628f38f4",
+ "data_fingerprint": "28844e0cd0f7c25c",
+ "initial_model_fingerprint": "cbffa45f13f8dead",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "clpso",
+ "profile": "clpso",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Comprehensive Learning PSO (CLPSO)",
+ "source": "10.1109/TEVC.2005.857610",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c": 1.49445,
+ "c0": 1.49445,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "refresh_gap": 7
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.15352463722229,
+ "accuracy": 0.26350000500679016,
+ "mse": 0.08546456694602966
+ },
+ "eval_metrics": {
+ "loss": 2.3076860904693604,
+ "accuracy": 0.1899999976158142,
+ "mse": 0.09044970571994781
+ },
+ "runtime_seconds": 3.502741124946624,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_bare_bones_seed41_5a20fcd6a522",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "5a20fcd6a522",
+ "data_fingerprint": "9cf90687f18f6867",
+ "initial_model_fingerprint": "a265005eab7305ab",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.9192537069320679,
+ "accuracy": 0.4334999918937683,
+ "mse": 0.0752088651061058
+ },
+ "eval_metrics": {
+ "loss": 1.989086627960205,
+ "accuracy": 0.40799999237060547,
+ "mse": 0.0770026221871376
+ },
+ "runtime_seconds": 3.6288448330014944,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_bare_bones_seed42_470567acfe4f",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "470567acfe4f",
+ "data_fingerprint": "dfe645918ece54c0",
+ "initial_model_fingerprint": "f15e396114108c51",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.7458051443099976,
+ "accuracy": 0.4424999952316284,
+ "mse": 0.0704411044716835
+ },
+ "eval_metrics": {
+ "loss": 1.7775629758834839,
+ "accuracy": 0.44999998807907104,
+ "mse": 0.07303041964769363
+ },
+ "runtime_seconds": 3.8391325410921127,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_bare_bones_seed43_8ab3c7a352f7",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "8ab3c7a352f7",
+ "data_fingerprint": "730cd610fc573af5",
+ "initial_model_fingerprint": "d9abe6f36969a8b5",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.8988544940948486,
+ "accuracy": 0.43050000071525574,
+ "mse": 0.07490310072898865
+ },
+ "eval_metrics": {
+ "loss": 2.171400547027588,
+ "accuracy": 0.3619999885559082,
+ "mse": 0.08386769145727158
+ },
+ "runtime_seconds": 3.29119808296673,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_bare_bones_seed44_97302dfc4390",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "97302dfc4390",
+ "data_fingerprint": "718e473f23ab68a4",
+ "initial_model_fingerprint": "497c2208b39cbf7e",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.7981884479522705,
+ "accuracy": 0.44999998807907104,
+ "mse": 0.07232917100191116
+ },
+ "eval_metrics": {
+ "loss": 1.795458197593689,
+ "accuracy": 0.44999998807907104,
+ "mse": 0.0723361149430275
+ },
+ "runtime_seconds": 3.362965959124267,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_bare_bones_seed45_47e574a6e14d",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "47e574a6e14d",
+ "data_fingerprint": "28844e0cd0f7c25c",
+ "initial_model_fingerprint": "cbffa45f13f8dead",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "bare_bones",
+ "profile": "bare_bones",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Bare Bones PSO",
+ "source": "10.1109/SIS.2003.1202251",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.855396032333374,
+ "accuracy": 0.44749999046325684,
+ "mse": 0.07144537568092346
+ },
+ "eval_metrics": {
+ "loss": 2.0943000316619873,
+ "accuracy": 0.3930000066757202,
+ "mse": 0.07978472113609314
+ },
+ "runtime_seconds": 3.057031667092815,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_adaptive_moment_seed41_362c2a6289bd",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "362c2a6289bd",
+ "data_fingerprint": "9cf90687f18f6867",
+ "initial_model_fingerprint": "a265005eab7305ab",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 41,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.2493228912353516,
+ "accuracy": 0.21950000524520874,
+ "mse": 0.08938036859035492
+ },
+ "eval_metrics": {
+ "loss": 2.140415906906128,
+ "accuracy": 0.2549999952316284,
+ "mse": 0.0860564336180687
+ },
+ "runtime_seconds": 2.7677273331210017,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_adaptive_moment_seed42_9ff2b9fb080a",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "9ff2b9fb080a",
+ "data_fingerprint": "dfe645918ece54c0",
+ "initial_model_fingerprint": "f15e396114108c51",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 42,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.1634159088134766,
+ "accuracy": 0.24699999392032623,
+ "mse": 0.08663105964660645
+ },
+ "eval_metrics": {
+ "loss": 2.141822576522827,
+ "accuracy": 0.24699999392032623,
+ "mse": 0.08651550859212875
+ },
+ "runtime_seconds": 3.0341640829574317,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_adaptive_moment_seed43_834468fb42c1",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "834468fb42c1",
+ "data_fingerprint": "730cd610fc573af5",
+ "initial_model_fingerprint": "d9abe6f36969a8b5",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 43,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.2793126106262207,
+ "accuracy": 0.2630000114440918,
+ "mse": 0.08873322606086731
+ },
+ "eval_metrics": {
+ "loss": 2.247786521911621,
+ "accuracy": 0.26899999380111694,
+ "mse": 0.08749625831842422
+ },
+ "runtime_seconds": 4.040982624981552,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_adaptive_moment_seed44_19c4f6565189",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "19c4f6565189",
+ "data_fingerprint": "718e473f23ab68a4",
+ "initial_model_fingerprint": "497c2208b39cbf7e",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 44,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.065256357192993,
+ "accuracy": 0.3174999952316284,
+ "mse": 0.08274290710687637
+ },
+ "eval_metrics": {
+ "loss": 2.1758370399475098,
+ "accuracy": 0.26899999380111694,
+ "mse": 0.0861084908246994
+ },
+ "runtime_seconds": 4.144569542026147,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "main_MNIST_adaptive_moment_seed45_475d6b29e2cd",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "475d6b29e2cd",
+ "data_fingerprint": "28844e0cd0f7c25c",
+ "initial_model_fingerprint": "cbffa45f13f8dead",
+ "type": "main",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "main",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment",
+ "seed": 45,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 0.5,
+ "c1": 0.3,
+ "w_min": 0.1,
+ "w_max": 0.9,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 2.1669728755950928,
+ "accuracy": 0.2919999957084656,
+ "mse": 0.08611716330051422
+ },
+ "eval_metrics": {
+ "loss": 2.3894264698028564,
+ "accuracy": 0.27000001072883606,
+ "mse": 0.08927067369222641
+ },
+ "runtime_seconds": 3.7505636250134557,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_inertia_canonical_seed46_057b98a366aa",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "057b98a366aa",
+ "data_fingerprint": "f6805de56ab56f4f",
+ "initial_model_fingerprint": "e0244bf7c9c050a7",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia_canonical",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "inertia_canonical",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "velocity_limit_ratio": 0.1,
+ "mutation_swarm": 0.0,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.4983471632003784,
+ "accuracy": 0.5414999723434448,
+ "mse": 0.06269210577011108
+ },
+ "eval_metrics": {
+ "loss": 1.591628074645996,
+ "accuracy": 0.492000013589859,
+ "mse": 0.0687657818198204
+ },
+ "runtime_seconds": 3.5609477078542113,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_inertia_canonical_seed47_c1675022f2d9",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "c1675022f2d9",
+ "data_fingerprint": "d6a0f7a23244f853",
+ "initial_model_fingerprint": "df5d443c5226f26e",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia_canonical",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "inertia_canonical",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "velocity_limit_ratio": 0.1,
+ "mutation_swarm": 0.0,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.6488323211669922,
+ "accuracy": 0.48350000381469727,
+ "mse": 0.06702468544244766
+ },
+ "eval_metrics": {
+ "loss": 1.7096999883651733,
+ "accuracy": 0.45399999618530273,
+ "mse": 0.07091139256954193
+ },
+ "runtime_seconds": 3.156672375043854,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_inertia_canonical_seed48_6b1583ef622c",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "6b1583ef622c",
+ "data_fingerprint": "8d32c9d5ee7cc371",
+ "initial_model_fingerprint": "949c6fb29dd9e30c",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia_canonical",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "inertia_canonical",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "velocity_limit_ratio": 0.1,
+ "mutation_swarm": 0.0,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.4587270021438599,
+ "accuracy": 0.5385000109672546,
+ "mse": 0.06065046414732933
+ },
+ "eval_metrics": {
+ "loss": 1.699597954750061,
+ "accuracy": 0.47200000286102295,
+ "mse": 0.06947261840105057
+ },
+ "runtime_seconds": 3.211212957976386,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_inertia_canonical_seed49_84f1dfaaa5c7",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "84f1dfaaa5c7",
+ "data_fingerprint": "fdb83bce228853a6",
+ "initial_model_fingerprint": "3ea1dc0a3bfd7e75",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia_canonical",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "inertia_canonical",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "velocity_limit_ratio": 0.1,
+ "mutation_swarm": 0.0,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.467037320137024,
+ "accuracy": 0.5584999918937683,
+ "mse": 0.061440981924533844
+ },
+ "eval_metrics": {
+ "loss": 1.6894328594207764,
+ "accuracy": 0.4869999885559082,
+ "mse": 0.06814173609018326
+ },
+ "runtime_seconds": 2.771214082837105,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_inertia_canonical_seed50_174a29344c8c",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "174a29344c8c",
+ "data_fingerprint": "4d8ed1f3d7ae6d21",
+ "initial_model_fingerprint": "30f656f9662701d1",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia_canonical",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "inertia_canonical",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "velocity_limit_ratio": 0.1,
+ "mutation_swarm": 0.0,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.5680404901504517,
+ "accuracy": 0.5164999961853027,
+ "mse": 0.06381449103355408
+ },
+ "eval_metrics": {
+ "loss": 1.9145543575286865,
+ "accuracy": 0.43299999833106995,
+ "mse": 0.07449053972959518
+ },
+ "runtime_seconds": 2.8994426249992102,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_inertia_tuned_seed46_f38d092547d4",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f38d092547d4",
+ "data_fingerprint": "f6805de56ab56f4f",
+ "initial_model_fingerprint": "e0244bf7c9c050a7",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia_tuned",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "inertia_tuned",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.960219144821167,
+ "accuracy": 0.7024999856948853,
+ "mse": 0.041494015604257584
+ },
+ "eval_metrics": {
+ "loss": 1.2107150554656982,
+ "accuracy": 0.6349999904632568,
+ "mse": 0.05100187286734581
+ },
+ "runtime_seconds": 2.6674257919657975,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_inertia_tuned_seed47_3d0dbe246d65",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "3d0dbe246d65",
+ "data_fingerprint": "d6a0f7a23244f853",
+ "initial_model_fingerprint": "df5d443c5226f26e",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia_tuned",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "inertia_tuned",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.926030158996582,
+ "accuracy": 0.7099999785423279,
+ "mse": 0.040029291063547134
+ },
+ "eval_metrics": {
+ "loss": 1.1810575723648071,
+ "accuracy": 0.6399999856948853,
+ "mse": 0.04994503781199455
+ },
+ "runtime_seconds": 2.9800681250635535,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_inertia_tuned_seed48_2c80a177eb48",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "2c80a177eb48",
+ "data_fingerprint": "8d32c9d5ee7cc371",
+ "initial_model_fingerprint": "949c6fb29dd9e30c",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia_tuned",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "inertia_tuned",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9870703220367432,
+ "accuracy": 0.703499972820282,
+ "mse": 0.042444709688425064
+ },
+ "eval_metrics": {
+ "loss": 1.1948310136795044,
+ "accuracy": 0.6480000019073486,
+ "mse": 0.05093942955136299
+ },
+ "runtime_seconds": 3.1290212909225374,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_inertia_tuned_seed49_bf8a511a1e7b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "bf8a511a1e7b",
+ "data_fingerprint": "fdb83bce228853a6",
+ "initial_model_fingerprint": "3ea1dc0a3bfd7e75",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia_tuned",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "inertia_tuned",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.1248133182525635,
+ "accuracy": 0.640999972820282,
+ "mse": 0.0484032966196537
+ },
+ "eval_metrics": {
+ "loss": 1.4542344808578491,
+ "accuracy": 0.5249999761581421,
+ "mse": 0.06324950605630875
+ },
+ "runtime_seconds": 3.097087916918099,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_inertia_tuned_seed50_f2df5809e1e5",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f2df5809e1e5",
+ "data_fingerprint": "4d8ed1f3d7ae6d21",
+ "initial_model_fingerprint": "30f656f9662701d1",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "inertia_tuned",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "inertia_tuned",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9994353652000427,
+ "accuracy": 0.7085000276565552,
+ "mse": 0.04210244119167328
+ },
+ "eval_metrics": {
+ "loss": 1.142163872718811,
+ "accuracy": 0.6330000162124634,
+ "mse": 0.04876433312892914
+ },
+ "runtime_seconds": 3.7858049999922514,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_no_mutation_seed46_8fc0f72ee8de",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "8fc0f72ee8de",
+ "data_fingerprint": "f6805de56ab56f4f",
+ "initial_model_fingerprint": "e0244bf7c9c050a7",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_no_mutation",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_no_mutation",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.0720897912979126,
+ "accuracy": 0.6589999794960022,
+ "mse": 0.04759814217686653
+ },
+ "eval_metrics": {
+ "loss": 1.2342966794967651,
+ "accuracy": 0.6060000061988831,
+ "mse": 0.05424211919307709
+ },
+ "runtime_seconds": 3.545372207881883,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_no_mutation_seed47_030a25514bc2",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "030a25514bc2",
+ "data_fingerprint": "d6a0f7a23244f853",
+ "initial_model_fingerprint": "df5d443c5226f26e",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_no_mutation",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_no_mutation",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.0350593328475952,
+ "accuracy": 0.6840000152587891,
+ "mse": 0.044449444860219955
+ },
+ "eval_metrics": {
+ "loss": 1.2122845649719238,
+ "accuracy": 0.6420000195503235,
+ "mse": 0.050288934260606766
+ },
+ "runtime_seconds": 3.1859298751223832,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_no_mutation_seed48_478a2b2f7d11",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "478a2b2f7d11",
+ "data_fingerprint": "8d32c9d5ee7cc371",
+ "initial_model_fingerprint": "949c6fb29dd9e30c",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_no_mutation",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_no_mutation",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.032089352607727,
+ "accuracy": 0.6794999837875366,
+ "mse": 0.04432502016425133
+ },
+ "eval_metrics": {
+ "loss": 1.1877166032791138,
+ "accuracy": 0.609000027179718,
+ "mse": 0.05128093436360359
+ },
+ "runtime_seconds": 2.969354083063081,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_no_mutation_seed49_07ee2e163664",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "07ee2e163664",
+ "data_fingerprint": "fdb83bce228853a6",
+ "initial_model_fingerprint": "3ea1dc0a3bfd7e75",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_no_mutation",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_no_mutation",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.0982294082641602,
+ "accuracy": 0.6660000085830688,
+ "mse": 0.04723907262086868
+ },
+ "eval_metrics": {
+ "loss": 1.2159452438354492,
+ "accuracy": 0.6069999933242798,
+ "mse": 0.05345964431762695
+ },
+ "runtime_seconds": 3.1995443750638515,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_no_mutation_seed50_55f1447345a7",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "55f1447345a7",
+ "data_fingerprint": "4d8ed1f3d7ae6d21",
+ "initial_model_fingerprint": "30f656f9662701d1",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_no_mutation",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_no_mutation",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.1345112323760986,
+ "accuracy": 0.6545000076293945,
+ "mse": 0.04792570322751999
+ },
+ "eval_metrics": {
+ "loss": 1.3989360332489014,
+ "accuracy": 0.5569999814033508,
+ "mse": 0.058142438530921936
+ },
+ "runtime_seconds": 3.8381401249207556,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_full_evaluation_seed46_34331f336517",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "34331f336517",
+ "data_fingerprint": "f6805de56ab56f4f",
+ "initial_model_fingerprint": "e0244bf7c9c050a7",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_full_evaluation",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_full_evaluation",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9815514087677002,
+ "accuracy": 0.7006666660308838,
+ "mse": 0.04276024550199509
+ },
+ "eval_metrics": {
+ "loss": 1.21538245677948,
+ "accuracy": 0.6169999837875366,
+ "mse": 0.05298233777284622
+ },
+ "runtime_seconds": 4.064853459130973,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_full_evaluation_seed47_47dacb349f42",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "47dacb349f42",
+ "data_fingerprint": "d6a0f7a23244f853",
+ "initial_model_fingerprint": "df5d443c5226f26e",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_full_evaluation",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_full_evaluation",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.0418089628219604,
+ "accuracy": 0.6726666688919067,
+ "mse": 0.04459879547357559
+ },
+ "eval_metrics": {
+ "loss": 1.2227095365524292,
+ "accuracy": 0.5839999914169312,
+ "mse": 0.054285984486341476
+ },
+ "runtime_seconds": 3.196830250089988,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_full_evaluation_seed48_f63dde67f916",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f63dde67f916",
+ "data_fingerprint": "8d32c9d5ee7cc371",
+ "initial_model_fingerprint": "949c6fb29dd9e30c",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_full_evaluation",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_full_evaluation",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9868288636207581,
+ "accuracy": 0.6850000023841858,
+ "mse": 0.04290908947587013
+ },
+ "eval_metrics": {
+ "loss": 1.1940710544586182,
+ "accuracy": 0.6240000128746033,
+ "mse": 0.05141150951385498
+ },
+ "runtime_seconds": 3.4551102090626955,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_full_evaluation_seed49_f4441b34504b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f4441b34504b",
+ "data_fingerprint": "fdb83bce228853a6",
+ "initial_model_fingerprint": "3ea1dc0a3bfd7e75",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_full_evaluation",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_full_evaluation",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.029543399810791,
+ "accuracy": 0.6859999895095825,
+ "mse": 0.04508155956864357
+ },
+ "eval_metrics": {
+ "loss": 1.1633678674697876,
+ "accuracy": 0.6460000276565552,
+ "mse": 0.051127687096595764
+ },
+ "runtime_seconds": 3.3989035410340875,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_full_evaluation_seed50_8df4579ac2af",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "8df4579ac2af",
+ "data_fingerprint": "4d8ed1f3d7ae6d21",
+ "initial_model_fingerprint": "30f656f9662701d1",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_full_evaluation",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_full_evaluation",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": null,
+ "batch_size": null,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9859696626663208,
+ "accuracy": 0.6949999928474426,
+ "mse": 0.042638495564460754
+ },
+ "eval_metrics": {
+ "loss": 1.0995144844055176,
+ "accuracy": 0.656000018119812,
+ "mse": 0.0478772297501564
+ },
+ "runtime_seconds": 2.7697177911177278,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_uniform_initialization_seed46_5544a2a1fbcd",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "5544a2a1fbcd",
+ "data_fingerprint": "f6805de56ab56f4f",
+ "initial_model_fingerprint": "e0244bf7c9c050a7",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_uniform_initialization",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_uniform_initialization",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "uniform",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Uniform Bounded Space Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.3547468185424805,
+ "accuracy": 0.6029999852180481,
+ "mse": 0.05597638711333275
+ },
+ "eval_metrics": {
+ "loss": 1.7022292613983154,
+ "accuracy": 0.5609999895095825,
+ "mse": 0.0650036409497261
+ },
+ "runtime_seconds": 4.465875457972288,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_uniform_initialization_seed47_f55eb979381b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f55eb979381b",
+ "data_fingerprint": "d6a0f7a23244f853",
+ "initial_model_fingerprint": "df5d443c5226f26e",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_uniform_initialization",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_uniform_initialization",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "uniform",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Uniform Bounded Space Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.3338260650634766,
+ "accuracy": 0.6150000095367432,
+ "mse": 0.0543423555791378
+ },
+ "eval_metrics": {
+ "loss": 1.807809591293335,
+ "accuracy": 0.5350000262260437,
+ "mse": 0.06686638295650482
+ },
+ "runtime_seconds": 4.935650583123788,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_uniform_initialization_seed48_f69a561bb4b0",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f69a561bb4b0",
+ "data_fingerprint": "8d32c9d5ee7cc371",
+ "initial_model_fingerprint": "949c6fb29dd9e30c",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_uniform_initialization",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_uniform_initialization",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "uniform",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Uniform Bounded Space Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.4022656679153442,
+ "accuracy": 0.6200000047683716,
+ "mse": 0.05426489934325218
+ },
+ "eval_metrics": {
+ "loss": 1.5523244142532349,
+ "accuracy": 0.578000009059906,
+ "mse": 0.05895908921957016
+ },
+ "runtime_seconds": 3.797271041199565,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_uniform_initialization_seed49_87b46efe8ead",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "87b46efe8ead",
+ "data_fingerprint": "fdb83bce228853a6",
+ "initial_model_fingerprint": "3ea1dc0a3bfd7e75",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_uniform_initialization",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_uniform_initialization",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "uniform",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Uniform Bounded Space Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.3672173023223877,
+ "accuracy": 0.6144999861717224,
+ "mse": 0.05405355617403984
+ },
+ "eval_metrics": {
+ "loss": 1.6415138244628906,
+ "accuracy": 0.574999988079071,
+ "mse": 0.061284471303224564
+ },
+ "runtime_seconds": 4.34765891591087,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_uniform_initialization_seed50_8fe90bb98ec5",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "8fe90bb98ec5",
+ "data_fingerprint": "4d8ed1f3d7ae6d21",
+ "initial_model_fingerprint": "30f656f9662701d1",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_uniform_initialization",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_uniform_initialization",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "uniform",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Uniform Bounded Space Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.2712308168411255,
+ "accuracy": 0.6274999976158142,
+ "mse": 0.05219874158501625
+ },
+ "eval_metrics": {
+ "loss": 1.392105221748352,
+ "accuracy": 0.6000000238418579,
+ "mse": 0.056670576333999634
+ },
+ "runtime_seconds": 3.9878762080334127,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_particle_reset_seed46_aabe31657e47",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "aabe31657e47",
+ "data_fingerprint": "f6805de56ab56f4f",
+ "initial_model_fingerprint": "e0244bf7c9c050a7",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_particle_reset",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_particle_reset",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "particle_reset",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "Particle Stagnation Reset",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "patience": 10,
+ "min_delta": 0.0001,
+ "monitor": "loss"
+ }
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.960219144821167,
+ "accuracy": 0.7024999856948853,
+ "mse": 0.041494015604257584
+ },
+ "eval_metrics": {
+ "loss": 1.2107150554656982,
+ "accuracy": 0.6349999904632568,
+ "mse": 0.05100187286734581
+ },
+ "runtime_seconds": 4.107592500047758,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_particle_reset_seed47_83feb7242779",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "83feb7242779",
+ "data_fingerprint": "d6a0f7a23244f853",
+ "initial_model_fingerprint": "df5d443c5226f26e",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_particle_reset",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_particle_reset",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "particle_reset",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "Particle Stagnation Reset",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "patience": 10,
+ "min_delta": 0.0001,
+ "monitor": "loss"
+ }
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.926030158996582,
+ "accuracy": 0.7099999785423279,
+ "mse": 0.040029291063547134
+ },
+ "eval_metrics": {
+ "loss": 1.1810575723648071,
+ "accuracy": 0.6399999856948853,
+ "mse": 0.04994503781199455
+ },
+ "runtime_seconds": 4.375917958794162,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_particle_reset_seed48_dfa908ae7828",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "dfa908ae7828",
+ "data_fingerprint": "8d32c9d5ee7cc371",
+ "initial_model_fingerprint": "949c6fb29dd9e30c",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_particle_reset",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_particle_reset",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "particle_reset",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "Particle Stagnation Reset",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "patience": 10,
+ "min_delta": 0.0001,
+ "monitor": "loss"
+ }
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9870703220367432,
+ "accuracy": 0.703499972820282,
+ "mse": 0.042444709688425064
+ },
+ "eval_metrics": {
+ "loss": 1.1948310136795044,
+ "accuracy": 0.6480000019073486,
+ "mse": 0.05093942955136299
+ },
+ "runtime_seconds": 4.824421874945983,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_particle_reset_seed49_648e2e926d70",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "648e2e926d70",
+ "data_fingerprint": "fdb83bce228853a6",
+ "initial_model_fingerprint": "3ea1dc0a3bfd7e75",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_particle_reset",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_particle_reset",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "particle_reset",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "Particle Stagnation Reset",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "patience": 10,
+ "min_delta": 0.0001,
+ "monitor": "loss"
+ }
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.1248133182525635,
+ "accuracy": 0.640999972820282,
+ "mse": 0.0484032966196537
+ },
+ "eval_metrics": {
+ "loss": 1.4542344808578491,
+ "accuracy": 0.5249999761581421,
+ "mse": 0.06324950605630875
+ },
+ "runtime_seconds": 3.64655854110606,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_particle_reset_seed50_7b83a61ec8d3",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7b83a61ec8d3",
+ "data_fingerprint": "4d8ed1f3d7ae6d21",
+ "initial_model_fingerprint": "30f656f9662701d1",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_particle_reset",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_particle_reset",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "particle_reset",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "Particle Stagnation Reset",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "patience": 10,
+ "min_delta": 0.0001,
+ "monitor": "loss"
+ }
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9994353652000427,
+ "accuracy": 0.7085000276565552,
+ "mse": 0.04210244119167328
+ },
+ "eval_metrics": {
+ "loss": 1.142163872718811,
+ "accuracy": 0.6330000162124634,
+ "mse": 0.04876433312892914
+ },
+ "runtime_seconds": 3.9274479581508785,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_adam_100_lr.01_seed46_2ab2dcb436f2",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "2ab2dcb436f2",
+ "data_fingerprint": "f6805de56ab56f4f",
+ "initial_model_fingerprint": "e0244bf7c9c050a7",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_adam_100_lr.01",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 1,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_adam_100_lr.01",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "adam",
+ "refinement_epochs": 100,
+ "refinement_lr": 0.01,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 1
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "Adam Post-Search Refinement",
+ "source": "10.1016/j.amc.2006.07.025",
+ "fidelity": "experimental",
+ "gradient_required": true,
+ "options": {
+ "epochs": 100,
+ "lr": 0.01
+ }
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.28509366512298584,
+ "accuracy": 0.9194999933242798,
+ "mse": 0.012805507518351078
+ },
+ "eval_metrics": {
+ "loss": 0.48086220026016235,
+ "accuracy": 0.859000027179718,
+ "mse": 0.021785300225019455
+ },
+ "runtime_seconds": 4.568401959026232,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_adam_100_lr.01_seed47_5349ad7d7d23",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "5349ad7d7d23",
+ "data_fingerprint": "d6a0f7a23244f853",
+ "initial_model_fingerprint": "df5d443c5226f26e",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_adam_100_lr.01",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 1,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_adam_100_lr.01",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "adam",
+ "refinement_epochs": 100,
+ "refinement_lr": 0.01,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 1
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "Adam Post-Search Refinement",
+ "source": "10.1016/j.amc.2006.07.025",
+ "fidelity": "experimental",
+ "gradient_required": true,
+ "options": {
+ "epochs": 100,
+ "lr": 0.01
+ }
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.28499677777290344,
+ "accuracy": 0.9185000061988831,
+ "mse": 0.012717506848275661
+ },
+ "eval_metrics": {
+ "loss": 0.4722329378128052,
+ "accuracy": 0.8560000061988831,
+ "mse": 0.021651843562722206
+ },
+ "runtime_seconds": 4.58812995813787,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_adam_100_lr.01_seed48_9e33bfe05a00",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "9e33bfe05a00",
+ "data_fingerprint": "8d32c9d5ee7cc371",
+ "initial_model_fingerprint": "949c6fb29dd9e30c",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_adam_100_lr.01",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 1,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_adam_100_lr.01",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "adam",
+ "refinement_epochs": 100,
+ "refinement_lr": 0.01,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 1
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "Adam Post-Search Refinement",
+ "source": "10.1016/j.amc.2006.07.025",
+ "fidelity": "experimental",
+ "gradient_required": true,
+ "options": {
+ "epochs": 100,
+ "lr": 0.01
+ }
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.31258782744407654,
+ "accuracy": 0.9104999899864197,
+ "mse": 0.01411585696041584
+ },
+ "eval_metrics": {
+ "loss": 0.48210030794143677,
+ "accuracy": 0.8529999852180481,
+ "mse": 0.02216770127415657
+ },
+ "runtime_seconds": 5.578959417063743,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_adam_100_lr.01_seed49_ad424ce3a736",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "ad424ce3a736",
+ "data_fingerprint": "fdb83bce228853a6",
+ "initial_model_fingerprint": "3ea1dc0a3bfd7e75",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_adam_100_lr.01",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 1,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_adam_100_lr.01",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "adam",
+ "refinement_epochs": 100,
+ "refinement_lr": 0.01,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 1
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "Adam Post-Search Refinement",
+ "source": "10.1016/j.amc.2006.07.025",
+ "fidelity": "experimental",
+ "gradient_required": true,
+ "options": {
+ "epochs": 100,
+ "lr": 0.01
+ }
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.3010714054107666,
+ "accuracy": 0.9175000190734863,
+ "mse": 0.013505849987268448
+ },
+ "eval_metrics": {
+ "loss": 0.45523107051849365,
+ "accuracy": 0.8539999723434448,
+ "mse": 0.021236121654510498
+ },
+ "runtime_seconds": 4.967162583954632,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_tuned_adam_100_lr.01_seed50_455af98e9a12",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "455af98e9a12",
+ "data_fingerprint": "4d8ed1f3d7ae6d21",
+ "initial_model_fingerprint": "30f656f9662701d1",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "inertia",
+ "profile": "tuned_adam_100_lr.01",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 1,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "inertia",
+ "profile": "tuned_adam_100_lr.01",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "adam",
+ "refinement_epochs": 100,
+ "refinement_lr": 0.01,
+ "moment_blend": null,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 1
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "Adam Post-Search Refinement",
+ "source": "10.1016/j.amc.2006.07.025",
+ "fidelity": "experimental",
+ "gradient_required": true,
+ "options": {
+ "epochs": 100,
+ "lr": 0.01
+ }
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.30886828899383545,
+ "accuracy": 0.9129999876022339,
+ "mse": 0.013552301563322544
+ },
+ "eval_metrics": {
+ "loss": 0.4609309732913971,
+ "accuracy": 0.8569999933242798,
+ "mse": 0.021361492574214935
+ },
+ "runtime_seconds": 5.250787208089605,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.10_seed46_79fac33a966b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "79fac33a966b",
+ "data_fingerprint": "f6805de56ab56f4f",
+ "initial_model_fingerprint": "e0244bf7c9c050a7",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.10",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.10",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.1,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9906385540962219,
+ "accuracy": 0.7269999980926514,
+ "mse": 0.03982372209429741
+ },
+ "eval_metrics": {
+ "loss": 1.3945393562316895,
+ "accuracy": 0.6050000190734863,
+ "mse": 0.05493663251399994
+ },
+ "runtime_seconds": 4.1654522500466555,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.10_seed47_2e7312e60eea",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "2e7312e60eea",
+ "data_fingerprint": "d6a0f7a23244f853",
+ "initial_model_fingerprint": "df5d443c5226f26e",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.10",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.10",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.1,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9854400753974915,
+ "accuracy": 0.7099999785423279,
+ "mse": 0.04110131040215492
+ },
+ "eval_metrics": {
+ "loss": 1.2537134885787964,
+ "accuracy": 0.6430000066757202,
+ "mse": 0.05136086419224739
+ },
+ "runtime_seconds": 4.548642375040799,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.10_seed48_3b5120f949a4",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "3b5120f949a4",
+ "data_fingerprint": "8d32c9d5ee7cc371",
+ "initial_model_fingerprint": "949c6fb29dd9e30c",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.10",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.10",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.1,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9406879544258118,
+ "accuracy": 0.7139999866485596,
+ "mse": 0.0401122123003006
+ },
+ "eval_metrics": {
+ "loss": 1.1160954236984253,
+ "accuracy": 0.6449999809265137,
+ "mse": 0.048475831747055054
+ },
+ "runtime_seconds": 4.156592082930729,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.10_seed49_6aec2466678e",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "6aec2466678e",
+ "data_fingerprint": "fdb83bce228853a6",
+ "initial_model_fingerprint": "3ea1dc0a3bfd7e75",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.10",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.10",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.1,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9904050827026367,
+ "accuracy": 0.6915000081062317,
+ "mse": 0.04313308745622635
+ },
+ "eval_metrics": {
+ "loss": 1.2602720260620117,
+ "accuracy": 0.6159999966621399,
+ "mse": 0.05337315797805786
+ },
+ "runtime_seconds": 3.9387462080921978,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.10_seed50_47fcaa850381",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "47fcaa850381",
+ "data_fingerprint": "4d8ed1f3d7ae6d21",
+ "initial_model_fingerprint": "30f656f9662701d1",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.10",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.10",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.1,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 0.9840501546859741,
+ "accuracy": 0.7070000171661377,
+ "mse": 0.04164457693696022
+ },
+ "eval_metrics": {
+ "loss": 1.1920746564865112,
+ "accuracy": 0.640999972820282,
+ "mse": 0.05001939460635185
+ },
+ "runtime_seconds": 4.623877624981105,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.25_seed46_cb952cfbbb2a",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "cb952cfbbb2a",
+ "data_fingerprint": "f6805de56ab56f4f",
+ "initial_model_fingerprint": "e0244bf7c9c050a7",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.25",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.25",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.25,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.2781139612197876,
+ "accuracy": 0.6215000152587891,
+ "mse": 0.05412229150533676
+ },
+ "eval_metrics": {
+ "loss": 1.3370016813278198,
+ "accuracy": 0.597000002861023,
+ "mse": 0.05697952210903168
+ },
+ "runtime_seconds": 3.9331418748479337,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.25_seed47_f961e70d98db",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "f961e70d98db",
+ "data_fingerprint": "d6a0f7a23244f853",
+ "initial_model_fingerprint": "df5d443c5226f26e",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.25",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.25",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.25,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.2477692365646362,
+ "accuracy": 0.6140000224113464,
+ "mse": 0.05316073074936867
+ },
+ "eval_metrics": {
+ "loss": 1.4836280345916748,
+ "accuracy": 0.546999990940094,
+ "mse": 0.06242356449365616
+ },
+ "runtime_seconds": 3.1843141668941826,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.25_seed48_78a29e6c1e9b",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "78a29e6c1e9b",
+ "data_fingerprint": "8d32c9d5ee7cc371",
+ "initial_model_fingerprint": "949c6fb29dd9e30c",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.25",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.25",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.25,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.0882177352905273,
+ "accuracy": 0.6765000224113464,
+ "mse": 0.04509768635034561
+ },
+ "eval_metrics": {
+ "loss": 1.5258105993270874,
+ "accuracy": 0.5690000057220459,
+ "mse": 0.06056499108672142
+ },
+ "runtime_seconds": 3.4833133339416236,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.25_seed49_e68caaec14b1",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "e68caaec14b1",
+ "data_fingerprint": "fdb83bce228853a6",
+ "initial_model_fingerprint": "3ea1dc0a3bfd7e75",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.25",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.25",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.25,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.3211814165115356,
+ "accuracy": 0.6365000009536743,
+ "mse": 0.05262219160795212
+ },
+ "eval_metrics": {
+ "loss": 1.6710549592971802,
+ "accuracy": 0.5220000147819519,
+ "mse": 0.06673089414834976
+ },
+ "runtime_seconds": 2.9174931249581277,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.25_seed50_7d9049b6cd03",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "7d9049b6cd03",
+ "data_fingerprint": "4d8ed1f3d7ae6d21",
+ "initial_model_fingerprint": "30f656f9662701d1",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.25",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.25",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.25,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.25,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.2048335075378418,
+ "accuracy": 0.640999972820282,
+ "mse": 0.05019155144691467
+ },
+ "eval_metrics": {
+ "loss": 1.4823977947235107,
+ "accuracy": 0.5809999704360962,
+ "mse": 0.05925340577960014
+ },
+ "runtime_seconds": 2.9364934579934925,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.50_seed46_6e28e68ad581",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "6e28e68ad581",
+ "data_fingerprint": "f6805de56ab56f4f",
+ "initial_model_fingerprint": "e0244bf7c9c050a7",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.50",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.50",
+ "seed": 46,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.5,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.5,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.6091550588607788,
+ "accuracy": 0.5379999876022339,
+ "mse": 0.06340662389993668
+ },
+ "eval_metrics": {
+ "loss": 1.8650866746902466,
+ "accuracy": 0.46799999475479126,
+ "mse": 0.07207556813955307
+ },
+ "runtime_seconds": 2.8238376670051366,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.50_seed47_5a30baac8420",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "5a30baac8420",
+ "data_fingerprint": "d6a0f7a23244f853",
+ "initial_model_fingerprint": "df5d443c5226f26e",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.50",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.50",
+ "seed": 47,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.5,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.5,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.4202409982681274,
+ "accuracy": 0.5985000133514404,
+ "mse": 0.05724874883890152
+ },
+ "eval_metrics": {
+ "loss": 1.7107937335968018,
+ "accuracy": 0.5289999842643738,
+ "mse": 0.06943122297525406
+ },
+ "runtime_seconds": 3.1655241248663515,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.50_seed48_2d3320a55ce6",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "2d3320a55ce6",
+ "data_fingerprint": "8d32c9d5ee7cc371",
+ "initial_model_fingerprint": "949c6fb29dd9e30c",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.50",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.50",
+ "seed": 48,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.5,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.5,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.465976357460022,
+ "accuracy": 0.5625,
+ "mse": 0.06070118770003319
+ },
+ "eval_metrics": {
+ "loss": 1.6830617189407349,
+ "accuracy": 0.5099999904632568,
+ "mse": 0.06682010740041733
+ },
+ "runtime_seconds": 3.564603833016008,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.50_seed49_47ddef54f059",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "47ddef54f059",
+ "data_fingerprint": "fdb83bce228853a6",
+ "initial_model_fingerprint": "3ea1dc0a3bfd7e75",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.50",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.50",
+ "seed": 49,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.5,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.5,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.342549204826355,
+ "accuracy": 0.5995000004768372,
+ "mse": 0.05577738210558891
+ },
+ "eval_metrics": {
+ "loss": 1.5354411602020264,
+ "accuracy": 0.5759999752044678,
+ "mse": 0.06179702281951904
+ },
+ "runtime_seconds": 3.145734125049785,
+ "completed": true,
+ "error": null
+ },
+ {
+ "run_id": "ablation_MNIST_adaptive_moment_.50_seed50_af889f537981",
+ "benchmark_protocol_version": "2.0.0",
+ "config_fingerprint": "af889f537981",
+ "data_fingerprint": "4d8ed1f3d7ae6d21",
+ "initial_model_fingerprint": "30f656f9662701d1",
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.50",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "score_source": "held_out",
+ "model_param_count": 330,
+ "train_data_size": 3000,
+ "eval_data_size": 1000,
+ "configured_pca_choice": {
+ "n_components": 32,
+ "whiten": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": true
+ },
+ "config": {
+ "benchmark_protocol_version": "2.0.0",
+ "quick": false,
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": "adaptive_moment",
+ "profile": "adaptive_moment_.50",
+ "seed": 50,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ "refinement_epochs": 0,
+ "refinement_lr": 0.001,
+ "moment_blend": 0.5,
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0
+ },
+ "resolved_plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.5,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "train_metrics": {
+ "loss": 1.4805761575698853,
+ "accuracy": 0.5540000200271606,
+ "mse": 0.060917943716049194
+ },
+ "eval_metrics": {
+ "loss": 1.6245237588882446,
+ "accuracy": 0.5099999904632568,
+ "mse": 0.0665321797132492
+ },
+ "runtime_seconds": 3.3128102091141045,
+ "completed": true,
+ "error": null
+ }
+ ],
+ "summaries": {
+ "main": [
+ {
+ "dataset": "XOR",
+ "method": "original",
+ "method_name": "original",
+ "n_particles": 24,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 1.0,
+ "std": 0.0,
+ "median": 1.0,
+ "iqr": 0.0,
+ "ci95_t": 0.0
+ },
+ "eval_loss": {
+ "mean": 0.004558,
+ "std": 0.002672,
+ "median": 0.004584,
+ "iqr": 0.001454,
+ "ci95_t": 0.003318
+ },
+ "eval_mse": {
+ "mean": 4.2e-05,
+ "std": 2.8e-05,
+ "median": 3.9e-05,
+ "iqr": 1.8e-05,
+ "ci95_t": 3.4e-05
+ },
+ "train_acc": {
+ "mean": 1.0,
+ "std": 0.0,
+ "median": 1.0,
+ "iqr": 0.0,
+ "ci95_t": 0.0
+ },
+ "train_loss": {
+ "mean": 0.004558,
+ "std": 0.002672,
+ "median": 0.004584,
+ "iqr": 0.001454,
+ "ci95_t": 0.003318
+ },
+ "runtime_seconds": {
+ "mean": 1.905231,
+ "std": 0.246635,
+ "median": 1.842664,
+ "iqr": 0.38231,
+ "ci95_t": 0.306233
+ },
+ "rank_acc": 3,
+ "rank_loss": 3
+ },
+ {
+ "dataset": "XOR",
+ "method": "inertia",
+ "method_name": "inertia",
+ "n_particles": 24,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 1.0,
+ "std": 0.0,
+ "median": 1.0,
+ "iqr": 0.0,
+ "ci95_t": 0.0
+ },
+ "eval_loss": {
+ "mean": 0.004431,
+ "std": 0.003308,
+ "median": 0.003801,
+ "iqr": 0.001559,
+ "ci95_t": 0.004108
+ },
+ "eval_mse": {
+ "mean": 3.6e-05,
+ "std": 3.1e-05,
+ "median": 2.8e-05,
+ "iqr": 1.5e-05,
+ "ci95_t": 3.9e-05
+ },
+ "train_acc": {
+ "mean": 1.0,
+ "std": 0.0,
+ "median": 1.0,
+ "iqr": 0.0,
+ "ci95_t": 0.0
+ },
+ "train_loss": {
+ "mean": 0.004431,
+ "std": 0.003308,
+ "median": 0.003801,
+ "iqr": 0.001559,
+ "ci95_t": 0.004108
+ },
+ "runtime_seconds": {
+ "mean": 1.969097,
+ "std": 0.170892,
+ "median": 2.068327,
+ "iqr": 0.219687,
+ "ci95_t": 0.212187
+ },
+ "rank_acc": 2,
+ "rank_loss": 2
+ },
+ {
+ "dataset": "XOR",
+ "method": "constriction",
+ "method_name": "constriction",
+ "n_particles": 24,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 1.0,
+ "std": 0.0,
+ "median": 1.0,
+ "iqr": 0.0,
+ "ci95_t": 0.0
+ },
+ "eval_loss": {
+ "mean": 0.004086,
+ "std": 0.002357,
+ "median": 0.005281,
+ "iqr": 0.001585,
+ "ci95_t": 0.002927
+ },
+ "eval_mse": {
+ "mean": 3.2e-05,
+ "std": 1.9e-05,
+ "median": 4.1e-05,
+ "iqr": 1.3e-05,
+ "ci95_t": 2.4e-05
+ },
+ "train_acc": {
+ "mean": 1.0,
+ "std": 0.0,
+ "median": 1.0,
+ "iqr": 0.0,
+ "ci95_t": 0.0
+ },
+ "train_loss": {
+ "mean": 0.004086,
+ "std": 0.002357,
+ "median": 0.005281,
+ "iqr": 0.001585,
+ "ci95_t": 0.002927
+ },
+ "runtime_seconds": {
+ "mean": 1.987776,
+ "std": 0.182034,
+ "median": 2.004753,
+ "iqr": 0.165649,
+ "ci95_t": 0.226021
+ },
+ "rank_acc": 1,
+ "rank_loss": 1
+ },
+ {
+ "dataset": "XOR",
+ "method": "fips",
+ "method_name": "fips",
+ "n_particles": 24,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.75,
+ "std": 0.25,
+ "median": 0.75,
+ "iqr": 0.5,
+ "ci95_t": 0.310411
+ },
+ "eval_loss": {
+ "mean": 0.546355,
+ "std": 0.059307,
+ "median": 0.568609,
+ "iqr": 0.092147,
+ "ci95_t": 0.073638
+ },
+ "eval_mse": {
+ "mean": 0.178887,
+ "std": 0.029466,
+ "median": 0.19088,
+ "iqr": 0.047686,
+ "ci95_t": 0.036586
+ },
+ "train_acc": {
+ "mean": 0.75,
+ "std": 0.25,
+ "median": 0.75,
+ "iqr": 0.5,
+ "ci95_t": 0.310411
+ },
+ "train_loss": {
+ "mean": 0.546355,
+ "std": 0.059307,
+ "median": 0.568609,
+ "iqr": 0.092147,
+ "ci95_t": 0.073638
+ },
+ "runtime_seconds": {
+ "mean": 2.502509,
+ "std": 0.055447,
+ "median": 2.493509,
+ "iqr": 0.06703,
+ "ci95_t": 0.068845
+ },
+ "rank_acc": 6,
+ "rank_loss": 6
+ },
+ {
+ "dataset": "XOR",
+ "method": "clpso",
+ "method_name": "clpso",
+ "n_particles": 24,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.6,
+ "std": 0.136931,
+ "median": 0.5,
+ "iqr": 0.25,
+ "ci95_t": 0.170019
+ },
+ "eval_loss": {
+ "mean": 0.548166,
+ "std": 0.031946,
+ "median": 0.55628,
+ "iqr": 0.024237,
+ "ci95_t": 0.039666
+ },
+ "eval_mse": {
+ "mean": 0.183052,
+ "std": 0.012602,
+ "median": 0.184625,
+ "iqr": 0.009748,
+ "ci95_t": 0.015648
+ },
+ "train_acc": {
+ "mean": 0.6,
+ "std": 0.136931,
+ "median": 0.5,
+ "iqr": 0.25,
+ "ci95_t": 0.170019
+ },
+ "train_loss": {
+ "mean": 0.548166,
+ "std": 0.031946,
+ "median": 0.55628,
+ "iqr": 0.024237,
+ "ci95_t": 0.039666
+ },
+ "runtime_seconds": {
+ "mean": 2.295572,
+ "std": 0.260868,
+ "median": 2.252497,
+ "iqr": 0.177013,
+ "ci95_t": 0.323906
+ },
+ "rank_acc": 7,
+ "rank_loss": 7
+ },
+ {
+ "dataset": "XOR",
+ "method": "bare_bones",
+ "method_name": "bare_bones",
+ "n_particles": 24,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 1.0,
+ "std": 0.0,
+ "median": 1.0,
+ "iqr": 0.0,
+ "ci95_t": 0.0
+ },
+ "eval_loss": {
+ "mean": 0.0821,
+ "std": 0.056963,
+ "median": 0.081613,
+ "iqr": 0.055056,
+ "ci95_t": 0.070728
+ },
+ "eval_mse": {
+ "mean": 0.010907,
+ "std": 0.010338,
+ "median": 0.011009,
+ "iqr": 0.011365,
+ "ci95_t": 0.012836
+ },
+ "train_acc": {
+ "mean": 1.0,
+ "std": 0.0,
+ "median": 1.0,
+ "iqr": 0.0,
+ "ci95_t": 0.0
+ },
+ "train_loss": {
+ "mean": 0.0821,
+ "std": 0.056963,
+ "median": 0.081613,
+ "iqr": 0.055056,
+ "ci95_t": 0.070728
+ },
+ "runtime_seconds": {
+ "mean": 2.031221,
+ "std": 0.13707,
+ "median": 2.017329,
+ "iqr": 0.208905,
+ "ci95_t": 0.170193
+ },
+ "rank_acc": 4,
+ "rank_loss": 4
+ },
+ {
+ "dataset": "XOR",
+ "method": "adaptive_moment",
+ "method_name": "adaptive_moment",
+ "n_particles": 24,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 1.0,
+ "std": 0.0,
+ "median": 1.0,
+ "iqr": 0.0,
+ "ci95_t": 0.0
+ },
+ "eval_loss": {
+ "mean": 0.190431,
+ "std": 0.178122,
+ "median": 0.197448,
+ "iqr": 0.188515,
+ "ci95_t": 0.221164
+ },
+ "eval_mse": {
+ "mean": 0.04504,
+ "std": 0.056878,
+ "median": 0.036092,
+ "iqr": 0.044696,
+ "ci95_t": 0.070623
+ },
+ "train_acc": {
+ "mean": 1.0,
+ "std": 0.0,
+ "median": 1.0,
+ "iqr": 0.0,
+ "ci95_t": 0.0
+ },
+ "train_loss": {
+ "mean": 0.190431,
+ "std": 0.178122,
+ "median": 0.197448,
+ "iqr": 0.188515,
+ "ci95_t": 0.221164
+ },
+ "runtime_seconds": {
+ "mean": 1.785274,
+ "std": 0.092073,
+ "median": 1.791596,
+ "iqr": 0.083435,
+ "ci95_t": 0.114322
+ },
+ "rank_acc": 5,
+ "rank_loss": 5
+ },
+ {
+ "dataset": "Iris",
+ "method": "original",
+ "method_name": "original",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.92,
+ "std": 0.086923,
+ "median": 0.966667,
+ "iqr": 0.033333,
+ "ci95_t": 0.107927
+ },
+ "eval_loss": {
+ "mean": 0.222324,
+ "std": 0.155767,
+ "median": 0.192657,
+ "iqr": 0.065706,
+ "ci95_t": 0.193407
+ },
+ "eval_mse": {
+ "mean": 0.043721,
+ "std": 0.035081,
+ "median": 0.032228,
+ "iqr": 0.016737,
+ "ci95_t": 0.043558
+ },
+ "train_acc": {
+ "mean": 0.966667,
+ "std": 0.010206,
+ "median": 0.966667,
+ "iqr": 0.008333,
+ "ci95_t": 0.012672
+ },
+ "train_loss": {
+ "mean": 0.08742,
+ "std": 0.02058,
+ "median": 0.092789,
+ "iqr": 0.019481,
+ "ci95_t": 0.025553
+ },
+ "runtime_seconds": {
+ "mean": 1.502316,
+ "std": 0.042929,
+ "median": 1.492559,
+ "iqr": 0.056936,
+ "ci95_t": 0.053303
+ },
+ "rank_acc": 3,
+ "rank_loss": 3
+ },
+ {
+ "dataset": "Iris",
+ "method": "inertia",
+ "method_name": "inertia",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.94,
+ "std": 0.027889,
+ "median": 0.933333,
+ "iqr": 0.033333,
+ "ci95_t": 0.034628
+ },
+ "eval_loss": {
+ "mean": 0.106901,
+ "std": 0.053063,
+ "median": 0.108104,
+ "iqr": 0.053939,
+ "ci95_t": 0.065885
+ },
+ "eval_mse": {
+ "mean": 0.024266,
+ "std": 0.011903,
+ "median": 0.026549,
+ "iqr": 0.016442,
+ "ci95_t": 0.014779
+ },
+ "train_acc": {
+ "mean": 0.983333,
+ "std": 0.005893,
+ "median": 0.983333,
+ "iqr": 0.0,
+ "ci95_t": 0.007316
+ },
+ "train_loss": {
+ "mean": 0.040899,
+ "std": 0.012351,
+ "median": 0.044929,
+ "iqr": 0.021993,
+ "ci95_t": 0.015335
+ },
+ "runtime_seconds": {
+ "mean": 1.569569,
+ "std": 0.121148,
+ "median": 1.529871,
+ "iqr": 0.105787,
+ "ci95_t": 0.150422
+ },
+ "rank_acc": 1,
+ "rank_loss": 1
+ },
+ {
+ "dataset": "Iris",
+ "method": "constriction",
+ "method_name": "constriction",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.94,
+ "std": 0.036515,
+ "median": 0.966667,
+ "iqr": 0.066667,
+ "ci95_t": 0.045338
+ },
+ "eval_loss": {
+ "mean": 0.171796,
+ "std": 0.076965,
+ "median": 0.148386,
+ "iqr": 0.105914,
+ "ci95_t": 0.095563
+ },
+ "eval_mse": {
+ "mean": 0.033793,
+ "std": 0.017284,
+ "median": 0.023024,
+ "iqr": 0.026996,
+ "ci95_t": 0.02146
+ },
+ "train_acc": {
+ "mean": 0.991667,
+ "std": 0.005893,
+ "median": 0.991667,
+ "iqr": 0.0,
+ "ci95_t": 0.007316
+ },
+ "train_loss": {
+ "mean": 0.032715,
+ "std": 0.011988,
+ "median": 0.032335,
+ "iqr": 0.014477,
+ "ci95_t": 0.014885
+ },
+ "runtime_seconds": {
+ "mean": 1.4309,
+ "std": 0.079265,
+ "median": 1.450687,
+ "iqr": 0.148585,
+ "ci95_t": 0.098419
+ },
+ "rank_acc": 2,
+ "rank_loss": 2
+ },
+ {
+ "dataset": "Iris",
+ "method": "fips",
+ "method_name": "fips",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.74,
+ "std": 0.054772,
+ "median": 0.733333,
+ "iqr": 0.033333,
+ "ci95_t": 0.068008
+ },
+ "eval_loss": {
+ "mean": 0.60501,
+ "std": 0.060601,
+ "median": 0.625894,
+ "iqr": 0.064748,
+ "ci95_t": 0.075245
+ },
+ "eval_mse": {
+ "mean": 0.117407,
+ "std": 0.008091,
+ "median": 0.120616,
+ "iqr": 0.009125,
+ "ci95_t": 0.010047
+ },
+ "train_acc": {
+ "mean": 0.766667,
+ "std": 0.083956,
+ "median": 0.741667,
+ "iqr": 0.05,
+ "ci95_t": 0.104243
+ },
+ "train_loss": {
+ "mean": 0.595101,
+ "std": 0.078408,
+ "median": 0.616142,
+ "iqr": 0.059233,
+ "ci95_t": 0.097354
+ },
+ "runtime_seconds": {
+ "mean": 2.072251,
+ "std": 0.154361,
+ "median": 2.009173,
+ "iqr": 0.038468,
+ "ci95_t": 0.191661
+ },
+ "rank_acc": 7,
+ "rank_loss": 7
+ },
+ {
+ "dataset": "Iris",
+ "method": "clpso",
+ "method_name": "clpso",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.793333,
+ "std": 0.076012,
+ "median": 0.766667,
+ "iqr": 0.066667,
+ "ci95_t": 0.094379
+ },
+ "eval_loss": {
+ "mean": 0.44827,
+ "std": 0.053877,
+ "median": 0.474597,
+ "iqr": 0.049216,
+ "ci95_t": 0.066896
+ },
+ "eval_mse": {
+ "mean": 0.091464,
+ "std": 0.016877,
+ "median": 0.091726,
+ "iqr": 0.010716,
+ "ci95_t": 0.020955
+ },
+ "train_acc": {
+ "mean": 0.78,
+ "std": 0.086321,
+ "median": 0.791667,
+ "iqr": 0.1,
+ "ci95_t": 0.10718
+ },
+ "train_loss": {
+ "mean": 0.462534,
+ "std": 0.114394,
+ "median": 0.44151,
+ "iqr": 0.072882,
+ "ci95_t": 0.142036
+ },
+ "runtime_seconds": {
+ "mean": 1.86465,
+ "std": 0.145025,
+ "median": 1.861528,
+ "iqr": 0.099452,
+ "ci95_t": 0.180069
+ },
+ "rank_acc": 6,
+ "rank_loss": 6
+ },
+ {
+ "dataset": "Iris",
+ "method": "bare_bones",
+ "method_name": "bare_bones",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.846667,
+ "std": 0.055777,
+ "median": 0.833333,
+ "iqr": 0.066667,
+ "ci95_t": 0.069256
+ },
+ "eval_loss": {
+ "mean": 0.405791,
+ "std": 0.172336,
+ "median": 0.367909,
+ "iqr": 0.160981,
+ "ci95_t": 0.21398
+ },
+ "eval_mse": {
+ "mean": 0.072802,
+ "std": 0.025814,
+ "median": 0.076178,
+ "iqr": 0.040948,
+ "ci95_t": 0.032051
+ },
+ "train_acc": {
+ "mean": 0.885,
+ "std": 0.046919,
+ "median": 0.891667,
+ "iqr": 0.075,
+ "ci95_t": 0.058257
+ },
+ "train_loss": {
+ "mean": 0.30248,
+ "std": 0.089572,
+ "median": 0.28258,
+ "iqr": 0.078565,
+ "ci95_t": 0.111216
+ },
+ "runtime_seconds": {
+ "mean": 1.66449,
+ "std": 0.144454,
+ "median": 1.714073,
+ "iqr": 0.185414,
+ "ci95_t": 0.17936
+ },
+ "rank_acc": 5,
+ "rank_loss": 5
+ },
+ {
+ "dataset": "Iris",
+ "method": "adaptive_moment",
+ "method_name": "adaptive_moment",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.846667,
+ "std": 0.076739,
+ "median": 0.866667,
+ "iqr": 0.133333,
+ "ci95_t": 0.095283
+ },
+ "eval_loss": {
+ "mean": 0.349701,
+ "std": 0.178108,
+ "median": 0.334009,
+ "iqr": 0.15044,
+ "ci95_t": 0.221147
+ },
+ "eval_mse": {
+ "mean": 0.071416,
+ "std": 0.035403,
+ "median": 0.063413,
+ "iqr": 0.0422,
+ "ci95_t": 0.043958
+ },
+ "train_acc": {
+ "mean": 0.89,
+ "std": 0.042246,
+ "median": 0.9,
+ "iqr": 0.016667,
+ "ci95_t": 0.052454
+ },
+ "train_loss": {
+ "mean": 0.294127,
+ "std": 0.078238,
+ "median": 0.297637,
+ "iqr": 0.053978,
+ "ci95_t": 0.097144
+ },
+ "runtime_seconds": {
+ "mean": 1.392557,
+ "std": 0.004708,
+ "median": 1.391352,
+ "iqr": 0.002098,
+ "ci95_t": 0.005846
+ },
+ "rank_acc": 4,
+ "rank_loss": 4
+ },
+ {
+ "dataset": "Seeds",
+ "method": "original",
+ "method_name": "original",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.87619,
+ "std": 0.042592,
+ "median": 0.880952,
+ "iqr": 0.071429,
+ "ci95_t": 0.052884
+ },
+ "eval_loss": {
+ "mean": 0.49224,
+ "std": 0.433653,
+ "median": 0.324954,
+ "iqr": 0.104917,
+ "ci95_t": 0.538443
+ },
+ "eval_mse": {
+ "mean": 0.065762,
+ "std": 0.028096,
+ "median": 0.051456,
+ "iqr": 0.032283,
+ "ci95_t": 0.034885
+ },
+ "train_acc": {
+ "mean": 0.916667,
+ "std": 0.030351,
+ "median": 0.928571,
+ "iqr": 0.035714,
+ "ci95_t": 0.037685
+ },
+ "train_loss": {
+ "mean": 0.246239,
+ "std": 0.069702,
+ "median": 0.241541,
+ "iqr": 0.047464,
+ "ci95_t": 0.086545
+ },
+ "runtime_seconds": {
+ "mean": 1.385803,
+ "std": 0.082957,
+ "median": 1.358886,
+ "iqr": 0.016763,
+ "ci95_t": 0.103003
+ },
+ "rank_acc": 5,
+ "rank_loss": 7
+ },
+ {
+ "dataset": "Seeds",
+ "method": "inertia",
+ "method_name": "inertia",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.914286,
+ "std": 0.052164,
+ "median": 0.928571,
+ "iqr": 0.023809,
+ "ci95_t": 0.064769
+ },
+ "eval_loss": {
+ "mean": 0.331656,
+ "std": 0.342636,
+ "median": 0.202104,
+ "iqr": 0.068956,
+ "ci95_t": 0.425432
+ },
+ "eval_mse": {
+ "mean": 0.048999,
+ "std": 0.036322,
+ "median": 0.039037,
+ "iqr": 0.008329,
+ "ci95_t": 0.045099
+ },
+ "train_acc": {
+ "mean": 0.963095,
+ "std": 0.018054,
+ "median": 0.964286,
+ "iqr": 0.017857,
+ "ci95_t": 0.022417
+ },
+ "train_loss": {
+ "mean": 0.103132,
+ "std": 0.034002,
+ "median": 0.106638,
+ "iqr": 0.012452,
+ "ci95_t": 0.042218
+ },
+ "runtime_seconds": {
+ "mean": 1.318196,
+ "std": 0.015319,
+ "median": 1.316955,
+ "iqr": 0.011708,
+ "ci95_t": 0.01902
+ },
+ "rank_acc": 1,
+ "rank_loss": 2
+ },
+ {
+ "dataset": "Seeds",
+ "method": "constriction",
+ "method_name": "constriction",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.890476,
+ "std": 0.091597,
+ "median": 0.880952,
+ "iqr": 0.095238,
+ "ci95_t": 0.113731
+ },
+ "eval_loss": {
+ "mean": 0.35142,
+ "std": 0.3882,
+ "median": 0.252366,
+ "iqr": 0.243302,
+ "ci95_t": 0.482006
+ },
+ "eval_mse": {
+ "mean": 0.056642,
+ "std": 0.052203,
+ "median": 0.058809,
+ "iqr": 0.043954,
+ "ci95_t": 0.064818
+ },
+ "train_acc": {
+ "mean": 0.960714,
+ "std": 0.017149,
+ "median": 0.970238,
+ "iqr": 0.017857,
+ "ci95_t": 0.021292
+ },
+ "train_loss": {
+ "mean": 0.100819,
+ "std": 0.037411,
+ "median": 0.110648,
+ "iqr": 0.057217,
+ "ci95_t": 0.046451
+ },
+ "runtime_seconds": {
+ "mean": 1.36371,
+ "std": 0.053261,
+ "median": 1.352828,
+ "iqr": 0.026591,
+ "ci95_t": 0.066131
+ },
+ "rank_acc": 3,
+ "rank_loss": 3
+ },
+ {
+ "dataset": "Seeds",
+ "method": "fips",
+ "method_name": "fips",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.885714,
+ "std": 0.035315,
+ "median": 0.880952,
+ "iqr": 0.02381,
+ "ci95_t": 0.043849
+ },
+ "eval_loss": {
+ "mean": 0.383732,
+ "std": 0.103951,
+ "median": 0.392303,
+ "iqr": 0.094168,
+ "ci95_t": 0.12907
+ },
+ "eval_mse": {
+ "mean": 0.067541,
+ "std": 0.016554,
+ "median": 0.068373,
+ "iqr": 0.011186,
+ "ci95_t": 0.020554
+ },
+ "train_acc": {
+ "mean": 0.9,
+ "std": 0.016517,
+ "median": 0.904762,
+ "iqr": 0.017857,
+ "ci95_t": 0.020508
+ },
+ "train_loss": {
+ "mean": 0.336734,
+ "std": 0.055168,
+ "median": 0.344263,
+ "iqr": 0.091857,
+ "ci95_t": 0.068498
+ },
+ "runtime_seconds": {
+ "mean": 1.815592,
+ "std": 0.045394,
+ "median": 1.793955,
+ "iqr": 0.066361,
+ "ci95_t": 0.056363
+ },
+ "rank_acc": 4,
+ "rank_loss": 4
+ },
+ {
+ "dataset": "Seeds",
+ "method": "clpso",
+ "method_name": "clpso",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.857143,
+ "std": 0.029161,
+ "median": 0.857143,
+ "iqr": 0.023809,
+ "ci95_t": 0.036207
+ },
+ "eval_loss": {
+ "mean": 0.469817,
+ "std": 0.073254,
+ "median": 0.510473,
+ "iqr": 0.12722,
+ "ci95_t": 0.090955
+ },
+ "eval_mse": {
+ "mean": 0.0841,
+ "std": 0.011752,
+ "median": 0.089405,
+ "iqr": 0.017131,
+ "ci95_t": 0.014592
+ },
+ "train_acc": {
+ "mean": 0.892857,
+ "std": 0.017857,
+ "median": 0.886905,
+ "iqr": 0.005952,
+ "ci95_t": 0.022172
+ },
+ "train_loss": {
+ "mean": 0.369897,
+ "std": 0.041768,
+ "median": 0.35888,
+ "iqr": 0.054595,
+ "ci95_t": 0.051862
+ },
+ "runtime_seconds": {
+ "mean": 1.537528,
+ "std": 0.018265,
+ "median": 1.533528,
+ "iqr": 0.022571,
+ "ci95_t": 0.022678
+ },
+ "rank_acc": 7,
+ "rank_loss": 6
+ },
+ {
+ "dataset": "Seeds",
+ "method": "bare_bones",
+ "method_name": "bare_bones",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.871429,
+ "std": 0.068595,
+ "median": 0.857143,
+ "iqr": 0.095238,
+ "ci95_t": 0.08517
+ },
+ "eval_loss": {
+ "mean": 0.42192,
+ "std": 0.120052,
+ "median": 0.439151,
+ "iqr": 0.13714,
+ "ci95_t": 0.149062
+ },
+ "eval_mse": {
+ "mean": 0.069299,
+ "std": 0.016028,
+ "median": 0.06829,
+ "iqr": 0.030136,
+ "ci95_t": 0.019901
+ },
+ "train_acc": {
+ "mean": 0.882143,
+ "std": 0.02036,
+ "median": 0.892857,
+ "iqr": 0.035714,
+ "ci95_t": 0.02528
+ },
+ "train_loss": {
+ "mean": 0.348336,
+ "std": 0.027942,
+ "median": 0.350757,
+ "iqr": 0.03937,
+ "ci95_t": 0.034694
+ },
+ "runtime_seconds": {
+ "mean": 1.54165,
+ "std": 0.018779,
+ "median": 1.536723,
+ "iqr": 0.022639,
+ "ci95_t": 0.023317
+ },
+ "rank_acc": 6,
+ "rank_loss": 5
+ },
+ {
+ "dataset": "Seeds",
+ "method": "adaptive_moment",
+ "method_name": "adaptive_moment",
+ "n_particles": 24,
+ "epochs": 60,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.890476,
+ "std": 0.046413,
+ "median": 0.904762,
+ "iqr": 0.047619,
+ "ci95_t": 0.057629
+ },
+ "eval_loss": {
+ "mean": 0.315947,
+ "std": 0.120895,
+ "median": 0.278367,
+ "iqr": 0.077865,
+ "ci95_t": 0.150108
+ },
+ "eval_mse": {
+ "mean": 0.053174,
+ "std": 0.012296,
+ "median": 0.050038,
+ "iqr": 0.020653,
+ "ci95_t": 0.015267
+ },
+ "train_acc": {
+ "mean": 0.917857,
+ "std": 0.007761,
+ "median": 0.916667,
+ "iqr": 0.011905,
+ "ci95_t": 0.009636
+ },
+ "train_loss": {
+ "mean": 0.225176,
+ "std": 0.034657,
+ "median": 0.229753,
+ "iqr": 0.016022,
+ "ci95_t": 0.043031
+ },
+ "runtime_seconds": {
+ "mean": 1.407326,
+ "std": 0.041435,
+ "median": 1.397074,
+ "iqr": 0.046223,
+ "ci95_t": 0.051447
+ },
+ "rank_acc": 2,
+ "rank_loss": 1
+ },
+ {
+ "dataset": "Digits",
+ "method": "original",
+ "method_name": "original",
+ "n_particles": 24,
+ "epochs": 50,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.164444,
+ "std": 0.022343,
+ "median": 0.158333,
+ "iqr": 0.036111,
+ "ci95_t": 0.027743
+ },
+ "eval_loss": {
+ "mean": 2.269628,
+ "std": 0.025331,
+ "median": 2.255083,
+ "iqr": 0.030712,
+ "ci95_t": 0.031453
+ },
+ "eval_mse": {
+ "mean": 0.089494,
+ "std": 0.000451,
+ "median": 0.089459,
+ "iqr": 0.000608,
+ "ci95_t": 0.00056
+ },
+ "train_acc": {
+ "mean": 0.1798,
+ "std": 0.024894,
+ "median": 0.168,
+ "iqr": 0.013,
+ "ci95_t": 0.030909
+ },
+ "train_loss": {
+ "mean": 2.266102,
+ "std": 0.042514,
+ "median": 2.261741,
+ "iqr": 0.048778,
+ "ci95_t": 0.052788
+ },
+ "runtime_seconds": {
+ "mean": 2.272324,
+ "std": 0.113557,
+ "median": 2.241578,
+ "iqr": 0.135688,
+ "ci95_t": 0.140997
+ },
+ "rank_acc": 7,
+ "rank_loss": 7
+ },
+ {
+ "dataset": "Digits",
+ "method": "inertia",
+ "method_name": "inertia",
+ "n_particles": 24,
+ "epochs": 50,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.303333,
+ "std": 0.061658,
+ "median": 0.305556,
+ "iqr": 0.088889,
+ "ci95_t": 0.076557
+ },
+ "eval_loss": {
+ "mean": 1.980667,
+ "std": 0.14307,
+ "median": 1.956439,
+ "iqr": 0.144242,
+ "ci95_t": 0.177642
+ },
+ "eval_mse": {
+ "mean": 0.080715,
+ "std": 0.004026,
+ "median": 0.079704,
+ "iqr": 0.005069,
+ "ci95_t": 0.004999
+ },
+ "train_acc": {
+ "mean": 0.297,
+ "std": 0.051595,
+ "median": 0.29,
+ "iqr": 0.068,
+ "ci95_t": 0.064062
+ },
+ "train_loss": {
+ "mean": 2.014632,
+ "std": 0.138786,
+ "median": 2.035008,
+ "iqr": 0.209018,
+ "ci95_t": 0.172322
+ },
+ "runtime_seconds": {
+ "mean": 2.006851,
+ "std": 0.09822,
+ "median": 1.968858,
+ "iqr": 0.103718,
+ "ci95_t": 0.121954
+ },
+ "rank_acc": 2,
+ "rank_loss": 2
+ },
+ {
+ "dataset": "Digits",
+ "method": "constriction",
+ "method_name": "constriction",
+ "n_particles": 24,
+ "epochs": 50,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.372778,
+ "std": 0.017938,
+ "median": 0.380556,
+ "iqr": 0.025,
+ "ci95_t": 0.022272
+ },
+ "eval_loss": {
+ "mean": 1.765113,
+ "std": 0.057309,
+ "median": 1.760801,
+ "iqr": 0.0677,
+ "ci95_t": 0.071157
+ },
+ "eval_mse": {
+ "mean": 0.074815,
+ "std": 0.001608,
+ "median": 0.074767,
+ "iqr": 0.002408,
+ "ci95_t": 0.001996
+ },
+ "train_acc": {
+ "mean": 0.382,
+ "std": 0.029351,
+ "median": 0.392,
+ "iqr": 0.045,
+ "ci95_t": 0.036444
+ },
+ "train_loss": {
+ "mean": 1.720719,
+ "std": 0.067535,
+ "median": 1.691806,
+ "iqr": 0.113772,
+ "ci95_t": 0.083855
+ },
+ "runtime_seconds": {
+ "mean": 2.330013,
+ "std": 0.148841,
+ "median": 2.375208,
+ "iqr": 0.085985,
+ "ci95_t": 0.184808
+ },
+ "rank_acc": 1,
+ "rank_loss": 1
+ },
+ {
+ "dataset": "Digits",
+ "method": "fips",
+ "method_name": "fips",
+ "n_particles": 24,
+ "epochs": 50,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.249444,
+ "std": 0.06147,
+ "median": 0.263889,
+ "iqr": 0.069444,
+ "ci95_t": 0.076324
+ },
+ "eval_loss": {
+ "mean": 2.064165,
+ "std": 0.091569,
+ "median": 2.064055,
+ "iqr": 0.108705,
+ "ci95_t": 0.113696
+ },
+ "eval_mse": {
+ "mean": 0.084041,
+ "std": 0.002578,
+ "median": 0.084591,
+ "iqr": 0.001907,
+ "ci95_t": 0.003201
+ },
+ "train_acc": {
+ "mean": 0.2662,
+ "std": 0.057399,
+ "median": 0.284,
+ "iqr": 0.087,
+ "ci95_t": 0.07127
+ },
+ "train_loss": {
+ "mean": 2.056891,
+ "std": 0.065924,
+ "median": 2.053429,
+ "iqr": 0.048116,
+ "ci95_t": 0.081854
+ },
+ "runtime_seconds": {
+ "mean": 2.621102,
+ "std": 0.126036,
+ "median": 2.634473,
+ "iqr": 0.0553,
+ "ci95_t": 0.156491
+ },
+ "rank_acc": 4,
+ "rank_loss": 3
+ },
+ {
+ "dataset": "Digits",
+ "method": "clpso",
+ "method_name": "clpso",
+ "n_particles": 24,
+ "epochs": 50,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.207778,
+ "std": 0.050629,
+ "median": 0.213889,
+ "iqr": 0.05,
+ "ci95_t": 0.062863
+ },
+ "eval_loss": {
+ "mean": 2.204543,
+ "std": 0.023215,
+ "median": 2.210108,
+ "iqr": 0.008743,
+ "ci95_t": 0.028825
+ },
+ "eval_mse": {
+ "mean": 0.087396,
+ "std": 0.001398,
+ "median": 0.087555,
+ "iqr": 0.000554,
+ "ci95_t": 0.001736
+ },
+ "train_acc": {
+ "mean": 0.223,
+ "std": 0.050656,
+ "median": 0.222,
+ "iqr": 0.008,
+ "ci95_t": 0.062896
+ },
+ "train_loss": {
+ "mean": 2.176502,
+ "std": 0.036771,
+ "median": 2.201568,
+ "iqr": 0.065228,
+ "ci95_t": 0.045657
+ },
+ "runtime_seconds": {
+ "mean": 2.519316,
+ "std": 0.326734,
+ "median": 2.377047,
+ "iqr": 0.074684,
+ "ci95_t": 0.405687
+ },
+ "rank_acc": 5,
+ "rank_loss": 5
+ },
+ {
+ "dataset": "Digits",
+ "method": "bare_bones",
+ "method_name": "bare_bones",
+ "n_particles": 24,
+ "epochs": 50,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.19,
+ "std": 0.056266,
+ "median": 0.155556,
+ "iqr": 0.1,
+ "ci95_t": 0.069863
+ },
+ "eval_loss": {
+ "mean": 2.250203,
+ "std": 0.084448,
+ "median": 2.251535,
+ "iqr": 0.020136,
+ "ci95_t": 0.104855
+ },
+ "eval_mse": {
+ "mean": 0.088622,
+ "std": 0.003141,
+ "median": 0.088919,
+ "iqr": 0.004198,
+ "ci95_t": 0.0039
+ },
+ "train_acc": {
+ "mean": 0.2,
+ "std": 0.037597,
+ "median": 0.191,
+ "iqr": 0.051,
+ "ci95_t": 0.046682
+ },
+ "train_loss": {
+ "mean": 2.230929,
+ "std": 0.042074,
+ "median": 2.252967,
+ "iqr": 0.025439,
+ "ci95_t": 0.052241
+ },
+ "runtime_seconds": {
+ "mean": 2.564876,
+ "std": 0.124195,
+ "median": 2.547843,
+ "iqr": 0.163155,
+ "ci95_t": 0.154206
+ },
+ "rank_acc": 6,
+ "rank_loss": 6
+ },
+ {
+ "dataset": "Digits",
+ "method": "adaptive_moment",
+ "method_name": "adaptive_moment",
+ "n_particles": 24,
+ "epochs": 50,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.267778,
+ "std": 0.018279,
+ "median": 0.272222,
+ "iqr": 0.002778,
+ "ci95_t": 0.022695
+ },
+ "eval_loss": {
+ "mean": 2.108837,
+ "std": 0.023357,
+ "median": 2.10196,
+ "iqr": 0.039265,
+ "ci95_t": 0.029001
+ },
+ "eval_mse": {
+ "mean": 0.084021,
+ "std": 0.001996,
+ "median": 0.083711,
+ "iqr": 0.001037,
+ "ci95_t": 0.002478
+ },
+ "train_acc": {
+ "mean": 0.2718,
+ "std": 0.026864,
+ "median": 0.271,
+ "iqr": 0.027,
+ "ci95_t": 0.033356
+ },
+ "train_loss": {
+ "mean": 2.086962,
+ "std": 0.042949,
+ "median": 2.079728,
+ "iqr": 0.056402,
+ "ci95_t": 0.053327
+ },
+ "runtime_seconds": {
+ "mean": 2.499448,
+ "std": 0.161274,
+ "median": 2.572057,
+ "iqr": 0.103131,
+ "ci95_t": 0.200245
+ },
+ "rank_acc": 3,
+ "rank_loss": 4
+ },
+ {
+ "dataset": "MNIST",
+ "method": "original",
+ "method_name": "original",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.144,
+ "std": 0.016628,
+ "median": 0.143,
+ "iqr": 0.026,
+ "ci95_t": 0.020646
+ },
+ "eval_loss": {
+ "mean": 2.428194,
+ "std": 0.091877,
+ "median": 2.415645,
+ "iqr": 0.154207,
+ "ci95_t": 0.114079
+ },
+ "eval_mse": {
+ "mean": 0.093035,
+ "std": 0.001872,
+ "median": 0.093503,
+ "iqr": 0.002477,
+ "ci95_t": 0.002324
+ },
+ "train_acc": {
+ "mean": 0.1563,
+ "std": 0.019709,
+ "median": 0.157,
+ "iqr": 0.0365,
+ "ci95_t": 0.024472
+ },
+ "train_loss": {
+ "mean": 2.385448,
+ "std": 0.06518,
+ "median": 2.393655,
+ "iqr": 0.05503,
+ "ci95_t": 0.08093
+ },
+ "runtime_seconds": {
+ "mean": 3.490117,
+ "std": 0.862784,
+ "median": 3.077394,
+ "iqr": 1.411307,
+ "ci95_t": 1.07127
+ },
+ "rank_acc": 7,
+ "rank_loss": 7
+ },
+ {
+ "dataset": "MNIST",
+ "method": "inertia",
+ "method_name": "inertia",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.4684,
+ "std": 0.075252,
+ "median": 0.497,
+ "iqr": 0.108,
+ "ci95_t": 0.093436
+ },
+ "eval_loss": {
+ "mean": 1.716089,
+ "std": 0.260764,
+ "median": 1.620183,
+ "iqr": 0.331954,
+ "ci95_t": 0.323776
+ },
+ "eval_mse": {
+ "mean": 0.070705,
+ "std": 0.008553,
+ "median": 0.067612,
+ "iqr": 0.011412,
+ "ci95_t": 0.01062
+ },
+ "train_acc": {
+ "mean": 0.552,
+ "std": 0.054511,
+ "median": 0.5635,
+ "iqr": 0.072,
+ "ci95_t": 0.067684
+ },
+ "train_loss": {
+ "mean": 1.44457,
+ "std": 0.147136,
+ "median": 1.428196,
+ "iqr": 0.173027,
+ "ci95_t": 0.18269
+ },
+ "runtime_seconds": {
+ "mean": 3.048485,
+ "std": 0.155303,
+ "median": 2.991671,
+ "iqr": 0.194157,
+ "ci95_t": 0.192831
+ },
+ "rank_acc": 2,
+ "rank_loss": 2
+ },
+ {
+ "dataset": "MNIST",
+ "method": "constriction",
+ "method_name": "constriction",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.52,
+ "std": 0.046244,
+ "median": 0.528,
+ "iqr": 0.047,
+ "ci95_t": 0.057418
+ },
+ "eval_loss": {
+ "mean": 1.507968,
+ "std": 0.149152,
+ "median": 1.509533,
+ "iqr": 0.108216,
+ "ci95_t": 0.185194
+ },
+ "eval_mse": {
+ "mean": 0.063327,
+ "std": 0.005427,
+ "median": 0.062376,
+ "iqr": 0.004698,
+ "ci95_t": 0.006738
+ },
+ "train_acc": {
+ "mean": 0.5968,
+ "std": 0.038889,
+ "median": 0.579,
+ "iqr": 0.0515,
+ "ci95_t": 0.048286
+ },
+ "train_loss": {
+ "mean": 1.284408,
+ "std": 0.114082,
+ "median": 1.34332,
+ "iqr": 0.186062,
+ "ci95_t": 0.141649
+ },
+ "runtime_seconds": {
+ "mean": 3.298112,
+ "std": 0.589527,
+ "median": 3.059424,
+ "iqr": 0.069755,
+ "ci95_t": 0.731982
+ },
+ "rank_acc": 1,
+ "rank_loss": 1
+ },
+ {
+ "dataset": "MNIST",
+ "method": "fips",
+ "method_name": "fips",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.2106,
+ "std": 0.048066,
+ "median": 0.229,
+ "iqr": 0.04,
+ "ci95_t": 0.05968
+ },
+ "eval_loss": {
+ "mean": 2.22323,
+ "std": 0.073048,
+ "median": 2.176908,
+ "iqr": 0.130584,
+ "ci95_t": 0.0907
+ },
+ "eval_mse": {
+ "mean": 0.088006,
+ "std": 0.001556,
+ "median": 0.087289,
+ "iqr": 0.001935,
+ "ci95_t": 0.001932
+ },
+ "train_acc": {
+ "mean": 0.2302,
+ "std": 0.057736,
+ "median": 0.225,
+ "iqr": 0.018,
+ "ci95_t": 0.071688
+ },
+ "train_loss": {
+ "mean": 2.177675,
+ "std": 0.093479,
+ "median": 2.200593,
+ "iqr": 0.060828,
+ "ci95_t": 0.116068
+ },
+ "runtime_seconds": {
+ "mean": 3.806571,
+ "std": 0.141017,
+ "median": 3.760384,
+ "iqr": 0.156547,
+ "ci95_t": 0.175093
+ },
+ "rank_acc": 5,
+ "rank_loss": 5
+ },
+ {
+ "dataset": "MNIST",
+ "method": "clpso",
+ "method_name": "clpso",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.2068,
+ "std": 0.022775,
+ "median": 0.2,
+ "iqr": 0.019,
+ "ci95_t": 0.028278
+ },
+ "eval_loss": {
+ "mean": 2.285833,
+ "std": 0.068177,
+ "median": 2.307686,
+ "iqr": 0.037065,
+ "ci95_t": 0.084651
+ },
+ "eval_mse": {
+ "mean": 0.089514,
+ "std": 0.00163,
+ "median": 0.089572,
+ "iqr": 0.001983,
+ "ci95_t": 0.002023
+ },
+ "train_acc": {
+ "mean": 0.2342,
+ "std": 0.028048,
+ "median": 0.246,
+ "iqr": 0.043,
+ "ci95_t": 0.034826
+ },
+ "train_loss": {
+ "mean": 2.199232,
+ "std": 0.089196,
+ "median": 2.172201,
+ "iqr": 0.096512,
+ "ci95_t": 0.110749
+ },
+ "runtime_seconds": {
+ "mean": 3.536445,
+ "std": 0.226486,
+ "median": 3.502741,
+ "iqr": 0.133258,
+ "ci95_t": 0.281215
+ },
+ "rank_acc": 6,
+ "rank_loss": 6
+ },
+ {
+ "dataset": "MNIST",
+ "method": "bare_bones",
+ "method_name": "bare_bones",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.4126,
+ "std": 0.037958,
+ "median": 0.408,
+ "iqr": 0.057,
+ "ci95_t": 0.04713
+ },
+ "eval_loss": {
+ "mean": 1.965562,
+ "std": 0.175909,
+ "median": 1.989087,
+ "iqr": 0.298842,
+ "ci95_t": 0.218416
+ },
+ "eval_mse": {
+ "mean": 0.077204,
+ "std": 0.004802,
+ "median": 0.077003,
+ "iqr": 0.006754,
+ "ci95_t": 0.005962
+ },
+ "train_acc": {
+ "mean": 0.4408,
+ "std": 0.008541,
+ "median": 0.4425,
+ "iqr": 0.014,
+ "ci95_t": 0.010605
+ },
+ "train_loss": {
+ "mean": 1.8435,
+ "std": 0.071662,
+ "median": 1.855396,
+ "iqr": 0.100666,
+ "ci95_t": 0.088978
+ },
+ "runtime_seconds": {
+ "mean": 3.435835,
+ "std": 0.303983,
+ "median": 3.362966,
+ "iqr": 0.337647,
+ "ci95_t": 0.377439
+ },
+ "rank_acc": 3,
+ "rank_loss": 3
+ },
+ {
+ "dataset": "MNIST",
+ "method": "adaptive_moment",
+ "method_name": "adaptive_moment",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.262,
+ "std": 0.01044,
+ "median": 0.269,
+ "iqr": 0.014,
+ "ci95_t": 0.012963
+ },
+ "eval_loss": {
+ "mean": 2.219058,
+ "std": 0.104724,
+ "median": 2.175837,
+ "iqr": 0.105964,
+ "ci95_t": 0.13003
+ },
+ "eval_mse": {
+ "mean": 0.087089,
+ "std": 0.001349,
+ "median": 0.086516,
+ "iqr": 0.001388,
+ "ci95_t": 0.001675
+ },
+ "train_acc": {
+ "mean": 0.2678,
+ "std": 0.038224,
+ "median": 0.263,
+ "iqr": 0.045,
+ "ci95_t": 0.047461
+ },
+ "train_loss": {
+ "mean": 2.184856,
+ "std": 0.083907,
+ "median": 2.166973,
+ "iqr": 0.085907,
+ "ci95_t": 0.104183
+ },
+ "runtime_seconds": {
+ "mean": 3.547601,
+ "std": 0.614982,
+ "median": 3.750564,
+ "iqr": 1.006819,
+ "ci95_t": 0.763589
+ },
+ "rank_acc": 4,
+ "rank_loss": 4
+ }
+ ],
+ "ablation": [
+ {
+ "dataset": "MNIST",
+ "profile": "inertia_canonical",
+ "method_name": "inertia",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.4676,
+ "std": 0.024358,
+ "median": 0.472,
+ "iqr": 0.033,
+ "ci95_t": 0.030244
+ },
+ "eval_loss": {
+ "mean": 1.720983,
+ "std": 0.118092,
+ "median": 1.699598,
+ "iqr": 0.020267,
+ "ci95_t": 0.146628
+ },
+ "eval_mse": {
+ "mean": 0.070356,
+ "std": 0.002531,
+ "median": 0.069473,
+ "iqr": 0.002146,
+ "ci95_t": 0.003142
+ },
+ "train_acc": {
+ "mean": 0.5277,
+ "std": 0.028874,
+ "median": 0.5385,
+ "iqr": 0.025,
+ "ci95_t": 0.035851
+ },
+ "train_loss": {
+ "mean": 1.528197,
+ "std": 0.079997,
+ "median": 1.498347,
+ "iqr": 0.101003,
+ "ci95_t": 0.099328
+ },
+ "runtime_seconds": {
+ "mean": 3.119898,
+ "std": 0.30594,
+ "median": 3.156672,
+ "iqr": 0.31177,
+ "ci95_t": 0.379868
+ },
+ "rank_acc": 10,
+ "rank_loss": 10
+ },
+ {
+ "dataset": "MNIST",
+ "profile": "inertia_tuned",
+ "method_name": "inertia",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.6162,
+ "std": 0.05131,
+ "median": 0.635,
+ "iqr": 0.007,
+ "ci95_t": 0.063709
+ },
+ "eval_loss": {
+ "mean": 1.2366,
+ "std": 0.124281,
+ "median": 1.194831,
+ "iqr": 0.029657,
+ "ci95_t": 0.154312
+ },
+ "eval_mse": {
+ "mean": 0.05278,
+ "std": 0.005923,
+ "median": 0.050939,
+ "iqr": 0.001057,
+ "ci95_t": 0.007354
+ },
+ "train_acc": {
+ "mean": 0.6931,
+ "std": 0.029299,
+ "median": 0.7035,
+ "iqr": 0.006,
+ "ci95_t": 0.036379
+ },
+ "train_loss": {
+ "mean": 0.999514,
+ "std": 0.075496,
+ "median": 0.98707,
+ "iqr": 0.039216,
+ "ci95_t": 0.093739
+ },
+ "runtime_seconds": {
+ "mean": 3.131882,
+ "std": 0.408534,
+ "median": 3.097088,
+ "iqr": 0.148953,
+ "ci95_t": 0.507254
+ },
+ "rank_acc": 4,
+ "rank_loss": 3
+ },
+ {
+ "dataset": "MNIST",
+ "profile": "tuned_no_mutation",
+ "method_name": "inertia",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.6042,
+ "std": 0.030376,
+ "median": 0.607,
+ "iqr": 0.003,
+ "ci95_t": 0.037716
+ },
+ "eval_loss": {
+ "mean": 1.249836,
+ "std": 0.084985,
+ "median": 1.215945,
+ "iqr": 0.022012,
+ "ci95_t": 0.105521
+ },
+ "eval_mse": {
+ "mean": 0.053483,
+ "std": 0.003055,
+ "median": 0.05346,
+ "iqr": 0.002961,
+ "ci95_t": 0.003794
+ },
+ "train_acc": {
+ "mean": 0.6686,
+ "std": 0.012784,
+ "median": 0.666,
+ "iqr": 0.0205,
+ "ci95_t": 0.015873
+ },
+ "train_loss": {
+ "mean": 1.074396,
+ "std": 0.043372,
+ "median": 1.07209,
+ "iqr": 0.06317,
+ "ci95_t": 0.053852
+ },
+ "runtime_seconds": {
+ "mean": 3.347668,
+ "std": 0.3431,
+ "median": 3.199544,
+ "iqr": 0.359442,
+ "ci95_t": 0.426008
+ },
+ "rank_acc": 6,
+ "rank_loss": 6
+ },
+ {
+ "dataset": "MNIST",
+ "profile": "tuned_full_evaluation",
+ "method_name": "inertia",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.6254,
+ "std": 0.02805,
+ "median": 0.624,
+ "iqr": 0.029,
+ "ci95_t": 0.034828
+ },
+ "eval_loss": {
+ "mean": 1.179009,
+ "std": 0.050059,
+ "median": 1.194071,
+ "iqr": 0.052015,
+ "ci95_t": 0.062156
+ },
+ "eval_mse": {
+ "mean": 0.051537,
+ "std": 0.00241,
+ "median": 0.051412,
+ "iqr": 0.001855,
+ "ci95_t": 0.002992
+ },
+ "train_acc": {
+ "mean": 0.687867,
+ "std": 0.010694,
+ "median": 0.686,
+ "iqr": 0.01,
+ "ci95_t": 0.013278
+ },
+ "train_loss": {
+ "mean": 1.00514,
+ "std": 0.028281,
+ "median": 0.986829,
+ "iqr": 0.043574,
+ "ci95_t": 0.035115
+ },
+ "runtime_seconds": {
+ "mean": 3.377083,
+ "std": 0.469302,
+ "median": 3.398904,
+ "iqr": 0.25828,
+ "ci95_t": 0.582705
+ },
+ "rank_acc": 3,
+ "rank_loss": 2
+ },
+ {
+ "dataset": "MNIST",
+ "profile": "tuned_uniform_initialization",
+ "method_name": "inertia",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.5698,
+ "std": 0.023952,
+ "median": 0.575,
+ "iqr": 0.017,
+ "ci95_t": 0.02974
+ },
+ "eval_loss": {
+ "mean": 1.619196,
+ "std": 0.157329,
+ "median": 1.641514,
+ "iqr": 0.149905,
+ "ci95_t": 0.195347
+ },
+ "eval_mse": {
+ "mean": 0.061757,
+ "std": 0.0042,
+ "median": 0.061284,
+ "iqr": 0.006045,
+ "ci95_t": 0.005215
+ },
+ "train_acc": {
+ "mean": 0.616,
+ "std": 0.008951,
+ "median": 0.615,
+ "iqr": 0.0055,
+ "ci95_t": 0.011114
+ },
+ "train_loss": {
+ "mean": 1.345857,
+ "std": 0.048557,
+ "median": 1.354747,
+ "iqr": 0.033391,
+ "ci95_t": 0.06029
+ },
+ "runtime_seconds": {
+ "mean": 4.306866,
+ "std": 0.442651,
+ "median": 4.347659,
+ "iqr": 0.477999,
+ "ci95_t": 0.549615
+ },
+ "rank_acc": 7,
+ "rank_loss": 8
+ },
+ {
+ "dataset": "MNIST",
+ "profile": "tuned_particle_reset",
+ "method_name": "inertia",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.6162,
+ "std": 0.05131,
+ "median": 0.635,
+ "iqr": 0.007,
+ "ci95_t": 0.063709
+ },
+ "eval_loss": {
+ "mean": 1.2366,
+ "std": 0.124281,
+ "median": 1.194831,
+ "iqr": 0.029657,
+ "ci95_t": 0.154312
+ },
+ "eval_mse": {
+ "mean": 0.05278,
+ "std": 0.005923,
+ "median": 0.050939,
+ "iqr": 0.001057,
+ "ci95_t": 0.007354
+ },
+ "train_acc": {
+ "mean": 0.6931,
+ "std": 0.029299,
+ "median": 0.7035,
+ "iqr": 0.006,
+ "ci95_t": 0.036379
+ },
+ "train_loss": {
+ "mean": 0.999514,
+ "std": 0.075496,
+ "median": 0.98707,
+ "iqr": 0.039216,
+ "ci95_t": 0.093739
+ },
+ "runtime_seconds": {
+ "mean": 4.176388,
+ "std": 0.449217,
+ "median": 4.107593,
+ "iqr": 0.44847,
+ "ci95_t": 0.557767
+ },
+ "rank_acc": 5,
+ "rank_loss": 4
+ },
+ {
+ "dataset": "MNIST",
+ "profile": "tuned_adam_100_lr.01",
+ "method_name": "inertia",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.8558,
+ "std": 0.002387,
+ "median": 0.856,
+ "iqr": 0.003,
+ "ci95_t": 0.002964
+ },
+ "eval_loss": {
+ "mean": 0.470271,
+ "std": 0.011931,
+ "median": 0.472233,
+ "iqr": 0.019931,
+ "ci95_t": 0.014814
+ },
+ "eval_mse": {
+ "mean": 0.02164,
+ "std": 0.000368,
+ "median": 0.021652,
+ "iqr": 0.000424,
+ "ci95_t": 0.000456
+ },
+ "train_acc": {
+ "mean": 0.9158,
+ "std": 0.003867,
+ "median": 0.9175,
+ "iqr": 0.0055,
+ "ci95_t": 0.004801
+ },
+ "train_loss": {
+ "mean": 0.298524,
+ "std": 0.012987,
+ "median": 0.301071,
+ "iqr": 0.023775,
+ "ci95_t": 0.016125
+ },
+ "runtime_seconds": {
+ "mean": 4.990688,
+ "std": 0.434352,
+ "median": 4.967163,
+ "iqr": 0.662657,
+ "ci95_t": 0.539311
+ },
+ "rank_acc": 1,
+ "rank_loss": 1
+ },
+ {
+ "dataset": "MNIST",
+ "profile": "adaptive_moment_.10",
+ "method_name": "adaptive_moment",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.63,
+ "std": 0.018276,
+ "median": 0.641,
+ "iqr": 0.027,
+ "ci95_t": 0.022692
+ },
+ "eval_loss": {
+ "mean": 1.243339,
+ "std": 0.102561,
+ "median": 1.253713,
+ "iqr": 0.068197,
+ "ci95_t": 0.127344
+ },
+ "eval_mse": {
+ "mean": 0.051633,
+ "std": 0.002578,
+ "median": 0.051361,
+ "iqr": 0.003354,
+ "ci95_t": 0.003201
+ },
+ "train_acc": {
+ "mean": 0.7099,
+ "std": 0.012808,
+ "median": 0.71,
+ "iqr": 0.007,
+ "ci95_t": 0.015903
+ },
+ "train_loss": {
+ "mean": 0.978244,
+ "std": 0.021198,
+ "median": 0.98544,
+ "iqr": 0.006355,
+ "ci95_t": 0.026321
+ },
+ "runtime_seconds": {
+ "mean": 4.286662,
+ "std": 0.289397,
+ "median": 4.165452,
+ "iqr": 0.39205,
+ "ci95_t": 0.359329
+ },
+ "rank_acc": 2,
+ "rank_loss": 5
+ },
+ {
+ "dataset": "MNIST",
+ "profile": "adaptive_moment_.25",
+ "method_name": "adaptive_moment",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.5632,
+ "std": 0.02938,
+ "median": 0.569,
+ "iqr": 0.034,
+ "ci95_t": 0.03648
+ },
+ "eval_loss": {
+ "mean": 1.499979,
+ "std": 0.119449,
+ "median": 1.483628,
+ "iqr": 0.043413,
+ "ci95_t": 0.148313
+ },
+ "eval_mse": {
+ "mean": 0.06119,
+ "std": 0.003677,
+ "median": 0.060565,
+ "iqr": 0.00317,
+ "ci95_t": 0.004566
+ },
+ "train_acc": {
+ "mean": 0.6379,
+ "std": 0.024196,
+ "median": 0.6365,
+ "iqr": 0.0195,
+ "ci95_t": 0.030042
+ },
+ "train_loss": {
+ "mean": 1.228023,
+ "std": 0.088967,
+ "median": 1.247769,
+ "iqr": 0.07328,
+ "ci95_t": 0.110466
+ },
+ "runtime_seconds": {
+ "mean": 3.290951,
+ "std": 0.425997,
+ "median": 3.184314,
+ "iqr": 0.54682,
+ "ci95_t": 0.528937
+ },
+ "rank_acc": 8,
+ "rank_loss": 7
+ },
+ {
+ "dataset": "MNIST",
+ "profile": "adaptive_moment_.50",
+ "method_name": "adaptive_moment",
+ "n_particles": 30,
+ "epochs": 80,
+ "n_runs": 5,
+ "eval_acc": {
+ "mean": 0.5186,
+ "std": 0.039087,
+ "median": 0.51,
+ "iqr": 0.019,
+ "ci95_t": 0.048532
+ },
+ "eval_loss": {
+ "mean": 1.683781,
+ "std": 0.121571,
+ "median": 1.683062,
+ "iqr": 0.08627,
+ "ci95_t": 0.150948
+ },
+ "eval_mse": {
+ "mean": 0.067331,
+ "std": 0.003822,
+ "median": 0.06682,
+ "iqr": 0.002899,
+ "ci95_t": 0.004746
+ },
+ "train_acc": {
+ "mean": 0.5705,
+ "std": 0.027466,
+ "median": 0.5625,
+ "iqr": 0.0445,
+ "ci95_t": 0.034103
+ },
+ "train_loss": {
+ "mean": 1.4637,
+ "std": 0.097485,
+ "median": 1.465976,
+ "iqr": 0.060335,
+ "ci95_t": 0.121042
+ },
+ "runtime_seconds": {
+ "mean": 3.202502,
+ "std": 0.269844,
+ "median": 3.165524,
+ "iqr": 0.167076,
+ "ci95_t": 0.33505
+ },
+ "rank_acc": 9,
+ "rank_loss": 9
+ }
+ ]
+ }
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v4_deep_accuracy.csv b/benchmark_results/pso_v4_deep_accuracy.csv
new file mode 100644
index 0000000..45dfc2f
--- /dev/null
+++ b/benchmark_results/pso_v4_deep_accuracy.csv
@@ -0,0 +1,19 @@
+lane,profile_or_arch,seed,model_name,param_count,initial_test_acc,final_test_acc,final_test_loss,subset_fitness_acc,subset_fitness_loss,pso_epochs,adam_epochs,elapsed_sec,model_fingerprint,data_fingerprint
+architecture,raw_linear,101,Raw Linear (784->10),7850,0.1449,0.9239,0.269691,,,0,10,2.6001,12cef21a80b85b0b,8dd702555745641a
+architecture,raw_linear,102,Raw Linear (784->10),7850,0.1308,0.924,0.270518,,,0,10,2.6265,0f099d5ae79e7863,8dd702555745641a
+architecture,raw_linear,103,Raw Linear (784->10),7850,0.0559,0.9257,0.266626,,,0,10,2.8535,23a4a6362abdad3d,8dd702555745641a
+architecture,raw_mlp,101,Raw MLP (784->128->64->10),109386,0.0812,0.9773,0.076661,,,0,10,8.8041,9ac96d5f45d71cb3,8dd702555745641a
+architecture,raw_mlp,102,Raw MLP (784->128->64->10),109386,0.0522,0.976,0.081621,,,0,10,5.7141,55966246db4dfff1,8dd702555745641a
+architecture,raw_mlp,103,Raw MLP (784->128->64->10),109386,0.1111,0.9776,0.076823,,,0,10,4.5491,723217e2418edcfd,8dd702555745641a
+architecture,compact_cnn,101,"Compact CNN (9,098 params)",9098,0.0851,0.9866,0.039444,,,0,10,6.228,db41fb515dcb49fa,8dd702555745641a
+architecture,compact_cnn,102,"Compact CNN (9,098 params)",9098,0.0963,0.9858,0.042864,,,0,10,5.396,efd743cad60c7530,8dd702555745641a
+architecture,compact_cnn,103,"Compact CNN (9,098 params)",9098,0.1072,0.9836,0.04912,,,0,10,5.4935,17891ec08e79ee74,8dd702555745641a
+optimizer,adam_only,101,Compact CNN (Adam-Only),9098,0.0851,0.9866,0.039444,,,0,10,6.228,db41fb515dcb49fa,8dd702555745641a
+optimizer,adam_only,102,Compact CNN (Adam-Only),9098,0.0963,0.9858,0.042864,,,0,10,5.396,efd743cad60c7530,8dd702555745641a
+optimizer,adam_only,103,Compact CNN (Adam-Only),9098,0.1072,0.9836,0.04912,,,0,10,5.4935,17891ec08e79ee74,8dd702555745641a
+optimizer,pso_only,101,Compact CNN (PSO-Only),9098,0.0851,0.3901,22.182518,0.399,21.674469,40,0,2.5761,db41fb515dcb49fa,8dd702555745641a
+optimizer,pso_only,102,Compact CNN (PSO-Only),9098,0.0963,0.3886,6.031698,0.3925,5.977414,40,0,2.331,efd743cad60c7530,8dd702555745641a
+optimizer,pso_only,103,Compact CNN (PSO-Only),9098,0.1072,0.3242,14.099036,0.3405,14.065619,40,0,2.7469,17891ec08e79ee74,8dd702555745641a
+optimizer,hybrid,101,Compact CNN (Hybrid),9098,0.0851,0.9658,0.109308,0.399,21.674469,40,10,7.4414,db41fb515dcb49fa,8dd702555745641a
+optimizer,hybrid,102,Compact CNN (Hybrid),9098,0.0963,0.9807,0.061528,0.3925,5.977414,40,10,7.226,efd743cad60c7530,8dd702555745641a
+optimizer,hybrid,103,Compact CNN (Hybrid),9098,0.1072,0.9725,0.088789,0.3405,14.065619,40,10,7.7426,17891ec08e79ee74,8dd702555745641a
diff --git a/benchmark_results/pso_v4_deep_accuracy.json b/benchmark_results/pso_v4_deep_accuracy.json
new file mode 100644
index 0000000..72cc464
--- /dev/null
+++ b/benchmark_results/pso_v4_deep_accuracy.json
@@ -0,0 +1,1444 @@
+{
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "timestamp": "2026-09-01T16:52:06.429839+00:00",
+ "completed": true,
+ "error": null,
+ "hardware_provenance": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "data_provenance": {
+ "input_shape": [
+ 1,
+ 28,
+ 28
+ ],
+ "pca": false,
+ "raw_inputs": true,
+ "normalization_scope": "official_train_split_60000_only",
+ "train_mean": 0.13066,
+ "train_std": 0.308108,
+ "train_samples": 60000,
+ "test_samples": 10000
+ },
+ "data_fingerprint": "8dd702555745641a",
+ "configuration": {
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ],
+ "adam_epochs": 10,
+ "pso_epochs": 40,
+ "particles": 30,
+ "fitness_size": 2000,
+ "batch_size": 256,
+ "lr": 0.001,
+ "device": "mps"
+ },
+ "summaries": {
+ "architecture_lane": {
+ "raw_linear": {
+ "mean": 0.924533,
+ "std": 0.001012,
+ "median": 0.924,
+ "iqr": 0.0009,
+ "ci95_t": 0.002513
+ },
+ "raw_mlp": {
+ "mean": 0.976967,
+ "std": 0.00085,
+ "median": 0.9773,
+ "iqr": 0.0008,
+ "ci95_t": 0.002113
+ },
+ "compact_cnn": {
+ "mean": 0.985333,
+ "std": 0.001553,
+ "median": 0.9858,
+ "iqr": 0.0015,
+ "ci95_t": 0.003859
+ }
+ },
+ "optimizer_lane": {
+ "adam_only": {
+ "mean": 0.985333,
+ "std": 0.001553,
+ "median": 0.9858,
+ "iqr": 0.0015,
+ "ci95_t": 0.003859
+ },
+ "pso_only": {
+ "mean": 0.367633,
+ "std": 0.037622,
+ "median": 0.3886,
+ "iqr": 0.03295,
+ "ci95_t": 0.093459
+ },
+ "hybrid": {
+ "mean": 0.973,
+ "std": 0.007463,
+ "median": 0.9725,
+ "iqr": 0.00745,
+ "ci95_t": 0.018538
+ }
+ }
+ },
+ "architecture_lane_runs": [
+ {
+ "lane": "architecture",
+ "profile_or_arch": "raw_linear",
+ "seed": 101,
+ "model_name": "Raw Linear (784->10)",
+ "param_count": 7850,
+ "initial_test_acc": 0.1449,
+ "final_test_acc": 0.9239,
+ "final_test_loss": 0.269691,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 2.6001,
+ "model_fingerprint": "12cef21a80b85b0b",
+ "data_fingerprint": "8dd702555745641a",
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.400093,
+ "test_acc": 0.1449
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.320512,
+ "test_acc": 0.909
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.288564,
+ "test_acc": 0.9168
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.276265,
+ "test_acc": 0.9201
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.273742,
+ "test_acc": 0.9202
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.269138,
+ "test_acc": 0.9236
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.268684,
+ "test_acc": 0.9236
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.268242,
+ "test_acc": 0.9253
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.266931,
+ "test_acc": 0.9258
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.26951,
+ "test_acc": 0.9242
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.269691,
+ "test_acc": 0.9239
+ }
+ ]
+ },
+ {
+ "lane": "architecture",
+ "profile_or_arch": "raw_linear",
+ "seed": 102,
+ "model_name": "Raw Linear (784->10)",
+ "param_count": 7850,
+ "initial_test_acc": 0.1308,
+ "final_test_acc": 0.924,
+ "final_test_loss": 0.270518,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 2.6265,
+ "model_fingerprint": "0f099d5ae79e7863",
+ "data_fingerprint": "8dd702555745641a",
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.472869,
+ "test_acc": 0.1308
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.322101,
+ "test_acc": 0.9087
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.293458,
+ "test_acc": 0.9172
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.278575,
+ "test_acc": 0.9225
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.277964,
+ "test_acc": 0.921
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.271165,
+ "test_acc": 0.9238
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.272923,
+ "test_acc": 0.9217
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.268772,
+ "test_acc": 0.925
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.267752,
+ "test_acc": 0.9245
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.266833,
+ "test_acc": 0.9239
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.270518,
+ "test_acc": 0.924
+ }
+ ]
+ },
+ {
+ "lane": "architecture",
+ "profile_or_arch": "raw_linear",
+ "seed": 103,
+ "model_name": "Raw Linear (784->10)",
+ "param_count": 7850,
+ "initial_test_acc": 0.0559,
+ "final_test_acc": 0.9257,
+ "final_test_loss": 0.266626,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 2.8535,
+ "model_fingerprint": "23a4a6362abdad3d",
+ "data_fingerprint": "8dd702555745641a",
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.515332,
+ "test_acc": 0.0559
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.324205,
+ "test_acc": 0.9089
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.293263,
+ "test_acc": 0.9173
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.285103,
+ "test_acc": 0.9159
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.274774,
+ "test_acc": 0.9221
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.275973,
+ "test_acc": 0.9215
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.271676,
+ "test_acc": 0.9253
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.26806,
+ "test_acc": 0.9245
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.269071,
+ "test_acc": 0.9226
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.269897,
+ "test_acc": 0.9248
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.266626,
+ "test_acc": 0.9257
+ }
+ ]
+ },
+ {
+ "lane": "architecture",
+ "profile_or_arch": "raw_mlp",
+ "seed": 101,
+ "model_name": "Raw MLP (784->128->64->10)",
+ "param_count": 109386,
+ "initial_test_acc": 0.0812,
+ "final_test_acc": 0.9773,
+ "final_test_loss": 0.076661,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 8.8041,
+ "model_fingerprint": "9ac96d5f45d71cb3",
+ "data_fingerprint": "8dd702555745641a",
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.313924,
+ "test_acc": 0.0812
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.204187,
+ "test_acc": 0.9369
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.143789,
+ "test_acc": 0.9558
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.114473,
+ "test_acc": 0.9665
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.095315,
+ "test_acc": 0.9705
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.084753,
+ "test_acc": 0.974
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.08701,
+ "test_acc": 0.9721
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.082966,
+ "test_acc": 0.9745
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.079873,
+ "test_acc": 0.9762
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.074512,
+ "test_acc": 0.9772
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.076661,
+ "test_acc": 0.9773
+ }
+ ]
+ },
+ {
+ "lane": "architecture",
+ "profile_or_arch": "raw_mlp",
+ "seed": 102,
+ "model_name": "Raw MLP (784->128->64->10)",
+ "param_count": 109386,
+ "initial_test_acc": 0.0522,
+ "final_test_acc": 0.976,
+ "final_test_loss": 0.081621,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 5.7141,
+ "model_fingerprint": "55966246db4dfff1",
+ "data_fingerprint": "8dd702555745641a",
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.311818,
+ "test_acc": 0.0522
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.195877,
+ "test_acc": 0.9408
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.146881,
+ "test_acc": 0.9566
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.113498,
+ "test_acc": 0.9656
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.100665,
+ "test_acc": 0.9678
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.091228,
+ "test_acc": 0.9728
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.080834,
+ "test_acc": 0.9755
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.084836,
+ "test_acc": 0.9734
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.079359,
+ "test_acc": 0.9765
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.077254,
+ "test_acc": 0.9769
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.081621,
+ "test_acc": 0.976
+ }
+ ]
+ },
+ {
+ "lane": "architecture",
+ "profile_or_arch": "raw_mlp",
+ "seed": 103,
+ "model_name": "Raw MLP (784->128->64->10)",
+ "param_count": 109386,
+ "initial_test_acc": 0.1111,
+ "final_test_acc": 0.9776,
+ "final_test_loss": 0.076823,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 4.5491,
+ "model_fingerprint": "723217e2418edcfd",
+ "data_fingerprint": "8dd702555745641a",
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.303093,
+ "test_acc": 0.1111
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.190557,
+ "test_acc": 0.9426
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.134924,
+ "test_acc": 0.9602
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.115296,
+ "test_acc": 0.9647
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.094033,
+ "test_acc": 0.9707
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.082773,
+ "test_acc": 0.9747
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.087643,
+ "test_acc": 0.9739
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.073957,
+ "test_acc": 0.9778
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.073425,
+ "test_acc": 0.9776
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.081665,
+ "test_acc": 0.9754
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.076823,
+ "test_acc": 0.9776
+ }
+ ]
+ },
+ {
+ "lane": "architecture",
+ "profile_or_arch": "compact_cnn",
+ "seed": 101,
+ "model_name": "Compact CNN (9,098 params)",
+ "param_count": 9098,
+ "initial_test_acc": 0.0851,
+ "final_test_acc": 0.9866,
+ "final_test_loss": 0.039444,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 6.228,
+ "model_fingerprint": "db41fb515dcb49fa",
+ "data_fingerprint": "8dd702555745641a",
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.310056,
+ "test_acc": 0.0851
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.146697,
+ "test_acc": 0.9577
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.087357,
+ "test_acc": 0.9714
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.068244,
+ "test_acc": 0.9775
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.058778,
+ "test_acc": 0.9804
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.052566,
+ "test_acc": 0.9808
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.044061,
+ "test_acc": 0.9848
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.043469,
+ "test_acc": 0.9843
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.043584,
+ "test_acc": 0.9851
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.047913,
+ "test_acc": 0.9831
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.039444,
+ "test_acc": 0.9866
+ }
+ ]
+ },
+ {
+ "lane": "architecture",
+ "profile_or_arch": "compact_cnn",
+ "seed": 102,
+ "model_name": "Compact CNN (9,098 params)",
+ "param_count": 9098,
+ "initial_test_acc": 0.0963,
+ "final_test_acc": 0.9858,
+ "final_test_loss": 0.042864,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 5.396,
+ "model_fingerprint": "efd743cad60c7530",
+ "data_fingerprint": "8dd702555745641a",
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.30391,
+ "test_acc": 0.0963
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.133494,
+ "test_acc": 0.9609
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.085325,
+ "test_acc": 0.9732
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.061211,
+ "test_acc": 0.9806
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.051721,
+ "test_acc": 0.9836
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.050876,
+ "test_acc": 0.9833
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.04746,
+ "test_acc": 0.9837
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.042635,
+ "test_acc": 0.9852
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.040222,
+ "test_acc": 0.9861
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.039712,
+ "test_acc": 0.9872
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.042864,
+ "test_acc": 0.9858
+ }
+ ]
+ },
+ {
+ "lane": "architecture",
+ "profile_or_arch": "compact_cnn",
+ "seed": 103,
+ "model_name": "Compact CNN (9,098 params)",
+ "param_count": 9098,
+ "initial_test_acc": 0.1072,
+ "final_test_acc": 0.9836,
+ "final_test_loss": 0.04912,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 5.4935,
+ "model_fingerprint": "17891ec08e79ee74",
+ "data_fingerprint": "8dd702555745641a",
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.280618,
+ "test_acc": 0.1072
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.166794,
+ "test_acc": 0.9515
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.095259,
+ "test_acc": 0.9708
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.072393,
+ "test_acc": 0.9769
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.06575,
+ "test_acc": 0.9791
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.056445,
+ "test_acc": 0.9811
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.051095,
+ "test_acc": 0.9842
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.049568,
+ "test_acc": 0.9827
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.046002,
+ "test_acc": 0.9847
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.047347,
+ "test_acc": 0.9847
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.04912,
+ "test_acc": 0.9836
+ }
+ ]
+ }
+ ],
+ "optimizer_lane_runs": [
+ {
+ "lane": "optimizer",
+ "profile_or_arch": "adam_only",
+ "seed": 101,
+ "model_name": "Compact CNN (Adam-Only)",
+ "param_count": 9098,
+ "initial_test_acc": 0.0851,
+ "final_test_acc": 0.9866,
+ "final_test_loss": 0.039444,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 6.228,
+ "model_fingerprint": "db41fb515dcb49fa",
+ "data_fingerprint": "8dd702555745641a",
+ "reused_from_architecture_lane": true,
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.310056,
+ "test_acc": 0.0851
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.146697,
+ "test_acc": 0.9577
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.087357,
+ "test_acc": 0.9714
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.068244,
+ "test_acc": 0.9775
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.058778,
+ "test_acc": 0.9804
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.052566,
+ "test_acc": 0.9808
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.044061,
+ "test_acc": 0.9848
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.043469,
+ "test_acc": 0.9843
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.043584,
+ "test_acc": 0.9851
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.047913,
+ "test_acc": 0.9831
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.039444,
+ "test_acc": 0.9866
+ }
+ ]
+ },
+ {
+ "lane": "optimizer",
+ "profile_or_arch": "adam_only",
+ "seed": 102,
+ "model_name": "Compact CNN (Adam-Only)",
+ "param_count": 9098,
+ "initial_test_acc": 0.0963,
+ "final_test_acc": 0.9858,
+ "final_test_loss": 0.042864,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 5.396,
+ "model_fingerprint": "efd743cad60c7530",
+ "data_fingerprint": "8dd702555745641a",
+ "reused_from_architecture_lane": true,
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.30391,
+ "test_acc": 0.0963
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.133494,
+ "test_acc": 0.9609
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.085325,
+ "test_acc": 0.9732
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.061211,
+ "test_acc": 0.9806
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.051721,
+ "test_acc": 0.9836
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.050876,
+ "test_acc": 0.9833
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.04746,
+ "test_acc": 0.9837
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.042635,
+ "test_acc": 0.9852
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.040222,
+ "test_acc": 0.9861
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.039712,
+ "test_acc": 0.9872
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.042864,
+ "test_acc": 0.9858
+ }
+ ]
+ },
+ {
+ "lane": "optimizer",
+ "profile_or_arch": "adam_only",
+ "seed": 103,
+ "model_name": "Compact CNN (Adam-Only)",
+ "param_count": 9098,
+ "initial_test_acc": 0.1072,
+ "final_test_acc": 0.9836,
+ "final_test_loss": 0.04912,
+ "subset_fitness_acc": null,
+ "subset_fitness_loss": null,
+ "pso_epochs": 0,
+ "adam_epochs": 10,
+ "elapsed_sec": 5.4935,
+ "model_fingerprint": "17891ec08e79ee74",
+ "data_fingerprint": "8dd702555745641a",
+ "reused_from_architecture_lane": true,
+ "epoch_history": [
+ {
+ "epoch": 0,
+ "test_loss": 2.280618,
+ "test_acc": 0.1072
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.166794,
+ "test_acc": 0.9515
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.095259,
+ "test_acc": 0.9708
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.072393,
+ "test_acc": 0.9769
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.06575,
+ "test_acc": 0.9791
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.056445,
+ "test_acc": 0.9811
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.051095,
+ "test_acc": 0.9842
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.049568,
+ "test_acc": 0.9827
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.046002,
+ "test_acc": 0.9847
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.047347,
+ "test_acc": 0.9847
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.04912,
+ "test_acc": 0.9836
+ }
+ ]
+ },
+ {
+ "lane": "optimizer",
+ "profile_or_arch": "pso_only",
+ "seed": 101,
+ "model_name": "Compact CNN (PSO-Only)",
+ "param_count": 9098,
+ "initial_test_acc": 0.0851,
+ "final_test_acc": 0.3901,
+ "final_test_loss": 22.182518,
+ "subset_fitness_acc": 0.399,
+ "subset_fitness_loss": 21.674469,
+ "pso_epochs": 40,
+ "adam_epochs": 0,
+ "elapsed_sec": 2.5761,
+ "model_fingerprint": "db41fb515dcb49fa",
+ "data_fingerprint": "8dd702555745641a",
+ "pso_metadata": {
+ "elapsed_sec": 2.5761,
+ "particles": 30,
+ "pso_epochs": 40,
+ "fitness_size": 2000,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ }
+ }
+ },
+ {
+ "lane": "optimizer",
+ "profile_or_arch": "pso_only",
+ "seed": 102,
+ "model_name": "Compact CNN (PSO-Only)",
+ "param_count": 9098,
+ "initial_test_acc": 0.0963,
+ "final_test_acc": 0.3886,
+ "final_test_loss": 6.031698,
+ "subset_fitness_acc": 0.3925,
+ "subset_fitness_loss": 5.977414,
+ "pso_epochs": 40,
+ "adam_epochs": 0,
+ "elapsed_sec": 2.331,
+ "model_fingerprint": "efd743cad60c7530",
+ "data_fingerprint": "8dd702555745641a",
+ "pso_metadata": {
+ "elapsed_sec": 2.331,
+ "particles": 30,
+ "pso_epochs": 40,
+ "fitness_size": 2000,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ }
+ }
+ },
+ {
+ "lane": "optimizer",
+ "profile_or_arch": "pso_only",
+ "seed": 103,
+ "model_name": "Compact CNN (PSO-Only)",
+ "param_count": 9098,
+ "initial_test_acc": 0.1072,
+ "final_test_acc": 0.3242,
+ "final_test_loss": 14.099036,
+ "subset_fitness_acc": 0.3405,
+ "subset_fitness_loss": 14.065619,
+ "pso_epochs": 40,
+ "adam_epochs": 0,
+ "elapsed_sec": 2.7469,
+ "model_fingerprint": "17891ec08e79ee74",
+ "data_fingerprint": "8dd702555745641a",
+ "pso_metadata": {
+ "elapsed_sec": 2.7469,
+ "particles": 30,
+ "pso_epochs": 40,
+ "fitness_size": 2000,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ }
+ }
+ },
+ {
+ "lane": "optimizer",
+ "profile_or_arch": "hybrid",
+ "seed": 101,
+ "model_name": "Compact CNN (Hybrid)",
+ "param_count": 9098,
+ "initial_test_acc": 0.0851,
+ "final_test_acc": 0.9658,
+ "final_test_loss": 0.109308,
+ "subset_fitness_acc": 0.399,
+ "subset_fitness_loss": 21.674469,
+ "pso_epochs": 40,
+ "adam_epochs": 10,
+ "elapsed_sec": 7.4414,
+ "model_fingerprint": "db41fb515dcb49fa",
+ "data_fingerprint": "8dd702555745641a",
+ "post_pso_test_acc": 0.3901,
+ "post_pso_test_loss": 22.182518,
+ "post_adam_history": [
+ {
+ "epoch": 0,
+ "test_loss": 22.182518,
+ "test_acc": 0.3901
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.906649,
+ "test_acc": 0.7792
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.464925,
+ "test_acc": 0.8794
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.311633,
+ "test_acc": 0.9154
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.238255,
+ "test_acc": 0.9325
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.19292,
+ "test_acc": 0.9433
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.166287,
+ "test_acc": 0.9493
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.141884,
+ "test_acc": 0.9583
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.124148,
+ "test_acc": 0.963
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.117039,
+ "test_acc": 0.9659
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.109308,
+ "test_acc": 0.9658
+ }
+ ],
+ "efficiency_label": "HYBRID_GETS_EXTRA_WORK_UNFAIR_EFFICIENCY_COMPARISON"
+ },
+ {
+ "lane": "optimizer",
+ "profile_or_arch": "hybrid",
+ "seed": 102,
+ "model_name": "Compact CNN (Hybrid)",
+ "param_count": 9098,
+ "initial_test_acc": 0.0963,
+ "final_test_acc": 0.9807,
+ "final_test_loss": 0.061528,
+ "subset_fitness_acc": 0.3925,
+ "subset_fitness_loss": 5.977414,
+ "pso_epochs": 40,
+ "adam_epochs": 10,
+ "elapsed_sec": 7.226,
+ "model_fingerprint": "efd743cad60c7530",
+ "data_fingerprint": "8dd702555745641a",
+ "post_pso_test_acc": 0.3886,
+ "post_pso_test_loss": 6.031698,
+ "post_adam_history": [
+ {
+ "epoch": 0,
+ "test_loss": 6.031698,
+ "test_acc": 0.3886
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.253423,
+ "test_acc": 0.9225
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.149914,
+ "test_acc": 0.9538
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.115633,
+ "test_acc": 0.9642
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.095672,
+ "test_acc": 0.9707
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.088199,
+ "test_acc": 0.9723
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.075571,
+ "test_acc": 0.9755
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.067953,
+ "test_acc": 0.9783
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.067223,
+ "test_acc": 0.978
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.065023,
+ "test_acc": 0.9801
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.061528,
+ "test_acc": 0.9807
+ }
+ ],
+ "efficiency_label": "HYBRID_GETS_EXTRA_WORK_UNFAIR_EFFICIENCY_COMPARISON"
+ },
+ {
+ "lane": "optimizer",
+ "profile_or_arch": "hybrid",
+ "seed": 103,
+ "model_name": "Compact CNN (Hybrid)",
+ "param_count": 9098,
+ "initial_test_acc": 0.1072,
+ "final_test_acc": 0.9725,
+ "final_test_loss": 0.088789,
+ "subset_fitness_acc": 0.3405,
+ "subset_fitness_loss": 14.065619,
+ "pso_epochs": 40,
+ "adam_epochs": 10,
+ "elapsed_sec": 7.7426,
+ "model_fingerprint": "17891ec08e79ee74",
+ "data_fingerprint": "8dd702555745641a",
+ "post_pso_test_acc": 0.3242,
+ "post_pso_test_loss": 14.099036,
+ "post_adam_history": [
+ {
+ "epoch": 0,
+ "test_loss": 14.099036,
+ "test_acc": 0.3242
+ },
+ {
+ "epoch": 1,
+ "test_loss": 0.543463,
+ "test_acc": 0.8485
+ },
+ {
+ "epoch": 2,
+ "test_loss": 0.308044,
+ "test_acc": 0.9105
+ },
+ {
+ "epoch": 3,
+ "test_loss": 0.22712,
+ "test_acc": 0.9322
+ },
+ {
+ "epoch": 4,
+ "test_loss": 0.17457,
+ "test_acc": 0.944
+ },
+ {
+ "epoch": 5,
+ "test_loss": 0.146244,
+ "test_acc": 0.9527
+ },
+ {
+ "epoch": 6,
+ "test_loss": 0.126948,
+ "test_acc": 0.9613
+ },
+ {
+ "epoch": 7,
+ "test_loss": 0.112113,
+ "test_acc": 0.9648
+ },
+ {
+ "epoch": 8,
+ "test_loss": 0.10164,
+ "test_acc": 0.9676
+ },
+ {
+ "epoch": 9,
+ "test_loss": 0.094236,
+ "test_acc": 0.9698
+ },
+ {
+ "epoch": 10,
+ "test_loss": 0.088789,
+ "test_acc": 0.9725
+ }
+ ],
+ "efficiency_label": "HYBRID_GETS_EXTRA_WORK_UNFAIR_EFFICIENCY_COMPARISON"
+ }
+ ]
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v4_epoch_convergence.csv b/benchmark_results/pso_v4_epoch_convergence.csv
new file mode 100644
index 0000000..597faf6
--- /dev/null
+++ b/benchmark_results/pso_v4_epoch_convergence.csv
@@ -0,0 +1,61 @@
+seed,epoch,train_loss,train_acc,train_mse,test_loss,test_acc,test_mse,fit_time_sec
+71,20,1.5967158079147339,0.4830000102519989,0.0660470575094223,1.7100492715835571,0.43799999356269836,0.07075551897287369,32.5467
+71,40,1.1239886283874512,0.6434999704360962,0.04822305589914322,1.3276519775390625,0.578000009059906,0.05614830181002617,32.5467
+71,60,0.8301568627357483,0.7429999709129333,0.03629826754331589,1.0045816898345947,0.6800000071525574,0.04412851482629776,32.5467
+71,80,0.6516683101654053,0.7950000166893005,0.028850017115473747,0.8584634065628052,0.7360000014305115,0.037673790007829666,32.5467
+71,100,0.5542685985565186,0.824999988079071,0.024905934929847717,0.7590173482894897,0.7620000243186951,0.03418450802564621,32.5467
+71,120,0.49202004075050354,0.8399999737739563,0.021997792646288872,0.7061744332313538,0.7889999747276306,0.03144212067127228,32.5467
+71,140,0.45162707567214966,0.8665000200271606,0.01984463632106781,0.6375347971916199,0.796999990940094,0.029180902987718582,32.5467
+71,160,0.4246227741241455,0.8740000128746033,0.018856780603528023,0.6248053312301636,0.8009999990463257,0.028511321172118187,32.5467
+71,180,0.39958131313323975,0.8799999952316284,0.01768091320991516,0.6031026244163513,0.8159999847412109,0.027248937636613846,32.5467
+71,200,0.3831179141998291,0.8924999833106995,0.016940467059612274,0.5841547846794128,0.8180000185966492,0.026774849742650986,32.5467
+71,220,0.36869707703590393,0.8970000147819519,0.016194477677345276,0.5548750162124634,0.8259999752044678,0.025661807507276535,32.5467
+71,240,0.3557758927345276,0.8989999890327454,0.015656106173992157,0.5201151371002197,0.8420000076293945,0.023789195343852043,32.5467
+72,20,1.673862338066101,0.46149998903274536,0.0692000463604927,1.8141505718231201,0.4099999964237213,0.07267315685749054,32.606
+72,40,1.1490310430526733,0.6324999928474426,0.04914539307355881,1.372908592224121,0.5709999799728394,0.05662866309285164,32.606
+72,60,0.8807169198989868,0.7369999885559082,0.03719912841916084,1.1267516613006592,0.6420000195503235,0.04854830726981163,32.606
+72,80,0.6982801556587219,0.7914999723434448,0.030153820291161537,0.9025362133979797,0.7239999771118164,0.038956169039011,32.606
+72,100,0.5910305380821228,0.8165000081062317,0.026041019707918167,0.7481632232666016,0.7570000290870667,0.03314316272735596,32.606
+72,120,0.5200771689414978,0.8464999794960022,0.022959064692258835,0.6597934365272522,0.7889999747276306,0.029753563925623894,32.606
+72,140,0.4719507694244385,0.8554999828338623,0.020908480510115623,0.58547043800354,0.8100000023841858,0.02705816738307476,32.606
+72,160,0.4356405735015869,0.871999979019165,0.019257094711065292,0.583936333656311,0.8220000267028809,0.026691943407058716,32.606
+72,180,0.4127918779850006,0.8725000023841858,0.018300892785191536,0.5632762312889099,0.8199999928474426,0.025847580283880234,32.606
+72,200,0.3940938115119934,0.8805000185966492,0.017671920359134674,0.5363063216209412,0.8339999914169312,0.024680841714143753,32.606
+72,220,0.37782323360443115,0.8845000267028809,0.017062701284885406,0.508123517036438,0.8399999737739563,0.023583590984344482,32.606
+72,240,0.36558520793914795,0.8899999856948853,0.01645873300731182,0.49120959639549255,0.8429999947547913,0.022604094818234444,32.606
+73,20,1.7135908603668213,0.4449999928474426,0.07240503281354904,1.8838708400726318,0.375,0.0778227150440216,32.7255
+73,40,1.2155654430389404,0.6340000033378601,0.051504913717508316,1.4863072633743286,0.5569999814033508,0.06111995875835419,32.7255
+73,60,0.9407793283462524,0.722000002861023,0.03982725366950035,1.1702646017074585,0.6439999938011169,0.049435749650001526,32.7255
+73,80,0.7527623772621155,0.7749999761581421,0.032556530088186264,1.001193642616272,0.6919999718666077,0.04309915751218796,32.7255
+73,100,0.6268301606178284,0.8140000104904175,0.027759678661823273,0.8296219706535339,0.7319999933242798,0.03728931397199631,32.7255
+73,120,0.5454505681991577,0.8320000171661377,0.02451479621231556,0.7347204089164734,0.7730000019073486,0.03278779238462448,32.7255
+73,140,0.46880221366882324,0.8575000166893005,0.021052677184343338,0.6670262813568115,0.7889999747276306,0.030432477593421936,32.7255
+73,160,0.43280255794525146,0.8659999966621399,0.01961500570178032,0.6248233914375305,0.8080000281333923,0.028731103986501694,32.7255
+73,180,0.4033927321434021,0.8790000081062317,0.017949724569916725,0.5680584907531738,0.8230000138282776,0.02612500637769699,32.7255
+73,200,0.3850976228713989,0.8880000114440918,0.017122117802500725,0.5508874654769897,0.8209999799728394,0.025604458525776863,32.7255
+73,220,0.3726767599582672,0.8899999856948853,0.016703158617019653,0.5412379503250122,0.8209999799728394,0.025124624371528625,32.7255
+73,240,0.3600545823574066,0.8989999890327454,0.016138451173901558,0.5263404250144958,0.8190000057220459,0.024716168642044067,32.7255
+74,20,1.5981744527816772,0.49950000643730164,0.06673180311918259,1.7434691190719604,0.42399999499320984,0.07240629941225052,32.9017
+74,40,1.1163724660873413,0.6600000262260437,0.047663308680057526,1.2812504768371582,0.6079999804496765,0.05496295168995857,32.9017
+74,60,0.8247233629226685,0.7429999709129333,0.03677733987569809,0.996366560459137,0.6800000071525574,0.044562000781297684,32.9017
+74,80,0.6858600974082947,0.784500002861023,0.030640259385108948,0.8601324558258057,0.7350000143051147,0.03845023736357689,32.9017
+74,100,0.5762760043144226,0.8274999856948853,0.025603292509913445,0.7484227418899536,0.7580000162124634,0.03352699801325798,32.9017
+74,120,0.5109706521034241,0.8500000238418579,0.02288639359176159,0.6725562810897827,0.7960000038146973,0.030220312997698784,32.9017
+74,140,0.4668312966823578,0.8600000143051147,0.021057307720184326,0.6381762623786926,0.8069999814033508,0.028759241104125977,32.9017
+74,160,0.430540531873703,0.8709999918937683,0.01937052235007286,0.6036783456802368,0.8169999718666077,0.026846695691347122,32.9017
+74,180,0.4092761278152466,0.8755000233650208,0.018336936831474304,0.5836188793182373,0.8199999928474426,0.0263815987855196,32.9017
+74,200,0.3926721215248108,0.8865000009536743,0.017603637650609016,0.5680423378944397,0.8270000219345093,0.02558077871799469,32.9017
+74,220,0.38078930974006653,0.8865000009536743,0.017137007787823677,0.5442376136779785,0.8379999995231628,0.024594470858573914,32.9017
+74,240,0.37086427211761475,0.8880000114440918,0.016686489805579185,0.5385385155677795,0.8299999833106995,0.024481549859046936,32.9017
+75,20,1.635738730430603,0.46950000524520874,0.06960180401802063,1.8486356735229492,0.4059999883174896,0.07580890506505966,32.7233
+75,40,1.0605015754699707,0.6604999899864197,0.04849516972899437,1.2981681823730469,0.5630000233650208,0.05867462605237961,32.7233
+75,60,0.7738548517227173,0.7615000009536743,0.03458299860358238,1.0294034481048584,0.671999990940094,0.04577324911952019,32.7233
+75,80,0.6326538324356079,0.8125,0.02839995175600052,0.889915406703949,0.7300000190734863,0.03931796923279762,32.7233
+75,100,0.529951810836792,0.8370000123977661,0.02384800836443901,0.762531042098999,0.7620000243186951,0.034515053033828735,32.7233
+75,120,0.47619307041168213,0.8575000166893005,0.021528739482164383,0.6571563482284546,0.781000018119812,0.030564110726118088,32.7233
+75,140,0.43610602617263794,0.8709999918937683,0.019426772370934486,0.6097874641418457,0.8140000104904175,0.028030628338456154,32.7233
+75,160,0.4064372479915619,0.8794999718666077,0.01836566999554634,0.5621976256370544,0.8309999704360962,0.025522591546177864,32.7233
+75,180,0.3866714835166931,0.8865000009536743,0.01732715405523777,0.557114839553833,0.8270000219345093,0.025415310636162758,32.7233
+75,200,0.37161633372306824,0.8855000138282776,0.016865627840161324,0.5388693809509277,0.8289999961853027,0.025061823427677155,32.7233
+75,220,0.3574405014514923,0.8939999938011169,0.016058821231126785,0.528910756111145,0.8289999961853027,0.024624072015285492,32.7233
+75,240,0.3456318974494934,0.8945000171661377,0.0156160369515419,0.5028988122940063,0.8420000076293945,0.023111792281270027,32.7233
diff --git a/benchmark_results/pso_v4_epoch_convergence.json b/benchmark_results/pso_v4_epoch_convergence.json
new file mode 100644
index 0000000..6d5bee4
--- /dev/null
+++ b/benchmark_results/pso_v4_epoch_convergence.json
@@ -0,0 +1,1334 @@
+{
+ "epoch_convergence_protocol_version": "1.0.0",
+ "tuning_protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "timestamp": "2026-09-02 00:01:42",
+ "baseline_path": "benchmark_results/pso_v4_tuning.json",
+ "data_fingerprint": "dfe645918ece54c0",
+ "candidate_label": "am_b0.06_s0.5",
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 240,
+ "batch_size": 1000,
+ "renewal": "loss",
+ "checkpoint_interval": 20
+ },
+ "contract_criteria": {
+ "primary_endpoints": [
+ 80,
+ 120,
+ 160,
+ 200,
+ 240
+ ],
+ "post_80_convergence_threshold_loss_reduction": 0.01,
+ "meaningful_gain_threshold_test_acc": 0.01,
+ "overfitting_threshold_test_acc": -0.01,
+ "late_plateau_200_240_loss_threshold": 0.01,
+ "late_plateau_200_240_acc_threshold": 0.005,
+ "replay_tolerance": 0.005
+ },
+ "fidelity_validation": {
+ "replay_seeds": [
+ 71,
+ 72,
+ 73,
+ 74,
+ 75
+ ],
+ "max_epoch80_test_acc_delta": 0.0,
+ "tolerance": 0.005,
+ "passed": true
+ },
+ "predeclared_classifications": {
+ "post_80_training_converging": true,
+ "meaningful_held_out_gain": true,
+ "overfitting_signal": false,
+ "early_stagnation": false,
+ "generalization_plateau": false,
+ "late_plateau_diagnostic": false,
+ "summary_verdict": "Training beyond epoch 80 continues to improve held-out test accuracy by 11.18 percentage points (from 72.34% to 83.52%)."
+ },
+ "summary": {
+ "epochs": [
+ 20,
+ 40,
+ 60,
+ 80,
+ 100,
+ 120,
+ 140,
+ 160,
+ 180,
+ 200,
+ 220,
+ 240
+ ],
+ "checkpoint_stats": {
+ "20": {
+ "train_loss": {
+ "mean": 1.643616,
+ "std": 0.050344,
+ "median": 1.635739,
+ "iqr": 0.075688,
+ "ci95_t": 0.062509
+ },
+ "train_acc": {
+ "mean": 0.4717,
+ "std": 0.02075,
+ "median": 0.4695,
+ "iqr": 0.0215,
+ "ci95_t": 0.025764
+ },
+ "train_mse": {
+ "mean": 0.068797,
+ "std": 0.002533,
+ "median": 0.0692,
+ "iqr": 0.00287,
+ "ci95_t": 0.003145
+ },
+ "test_loss": {
+ "mean": 1.800035,
+ "std": 0.072261,
+ "median": 1.814151,
+ "iqr": 0.105167,
+ "ci95_t": 0.089723
+ },
+ "test_acc": {
+ "mean": 0.4106,
+ "std": 0.023554,
+ "median": 0.41,
+ "iqr": 0.018,
+ "ci95_t": 0.029246
+ },
+ "test_mse": {
+ "mean": 0.073893,
+ "std": 0.002857,
+ "median": 0.072673,
+ "iqr": 0.003403,
+ "ci95_t": 0.003548
+ }
+ },
+ "40": {
+ "train_loss": {
+ "mean": 1.133092,
+ "std": 0.05632,
+ "median": 1.123989,
+ "iqr": 0.032659,
+ "ci95_t": 0.069929
+ },
+ "train_acc": {
+ "mean": 0.6461,
+ "std": 0.01359,
+ "median": 0.6435,
+ "iqr": 0.026,
+ "ci95_t": 0.016873
+ },
+ "train_mse": {
+ "mean": 0.049006,
+ "std": 0.001495,
+ "median": 0.048495,
+ "iqr": 0.000922,
+ "ci95_t": 0.001856
+ },
+ "test_loss": {
+ "mean": 1.353257,
+ "std": 0.082103,
+ "median": 1.327652,
+ "iqr": 0.07474,
+ "ci95_t": 0.101943
+ },
+ "test_acc": {
+ "mean": 0.5754,
+ "std": 0.019882,
+ "median": 0.571,
+ "iqr": 0.015,
+ "ci95_t": 0.024687
+ },
+ "test_mse": {
+ "mean": 0.057507,
+ "std": 0.002424,
+ "median": 0.056629,
+ "iqr": 0.002526,
+ "ci95_t": 0.00301
+ }
+ },
+ "60": {
+ "train_loss": {
+ "mean": 0.850046,
+ "std": 0.063275,
+ "median": 0.830157,
+ "iqr": 0.055994,
+ "ci95_t": 0.078566
+ },
+ "train_acc": {
+ "mean": 0.7413,
+ "std": 0.014184,
+ "median": 0.743,
+ "iqr": 0.006,
+ "ci95_t": 0.017612
+ },
+ "train_mse": {
+ "mean": 0.036937,
+ "std": 0.001897,
+ "median": 0.036777,
+ "iqr": 0.000901,
+ "ci95_t": 0.002356
+ },
+ "test_loss": {
+ "mean": 1.065474,
+ "std": 0.078296,
+ "median": 1.029403,
+ "iqr": 0.12217,
+ "ci95_t": 0.097215
+ },
+ "test_acc": {
+ "mean": 0.6636,
+ "std": 0.0191,
+ "median": 0.672,
+ "iqr": 0.036,
+ "ci95_t": 0.023715
+ },
+ "test_mse": {
+ "mean": 0.04649,
+ "std": 0.002383,
+ "median": 0.045773,
+ "iqr": 0.003986,
+ "ci95_t": 0.002959
+ }
+ },
+ "80": {
+ "train_loss": {
+ "mean": 0.684245,
+ "std": 0.046414,
+ "median": 0.68586,
+ "iqr": 0.046612,
+ "ci95_t": 0.05763
+ },
+ "train_acc": {
+ "mean": 0.7917,
+ "std": 0.013913,
+ "median": 0.7915,
+ "iqr": 0.0105,
+ "ci95_t": 0.017275
+ },
+ "train_mse": {
+ "mean": 0.03012,
+ "std": 0.001642,
+ "median": 0.030154,
+ "iqr": 0.00179,
+ "ci95_t": 0.002038
+ },
+ "test_loss": {
+ "mean": 0.902448,
+ "std": 0.05838,
+ "median": 0.889915,
+ "iqr": 0.042404,
+ "ci95_t": 0.072488
+ },
+ "test_acc": {
+ "mean": 0.7234,
+ "std": 0.018188,
+ "median": 0.73,
+ "iqr": 0.011,
+ "ci95_t": 0.022583
+ },
+ "test_mse": {
+ "mean": 0.039499,
+ "std": 0.002105,
+ "median": 0.038956,
+ "iqr": 0.000868,
+ "ci95_t": 0.002613
+ }
+ },
+ "100": {
+ "train_loss": {
+ "mean": 0.575671,
+ "std": 0.036749,
+ "median": 0.576276,
+ "iqr": 0.036762,
+ "ci95_t": 0.045629
+ },
+ "train_acc": {
+ "mean": 0.824,
+ "std": 0.009199,
+ "median": 0.825,
+ "iqr": 0.011,
+ "ci95_t": 0.011422
+ },
+ "train_mse": {
+ "mean": 0.025632,
+ "std": 0.00145,
+ "median": 0.025603,
+ "iqr": 0.001135,
+ "ci95_t": 0.0018
+ },
+ "test_loss": {
+ "mean": 0.769551,
+ "std": 0.034178,
+ "median": 0.759017,
+ "iqr": 0.014108,
+ "ci95_t": 0.042437
+ },
+ "test_acc": {
+ "mean": 0.7542,
+ "std": 0.012617,
+ "median": 0.758,
+ "iqr": 0.005,
+ "ci95_t": 0.015666
+ },
+ "test_mse": {
+ "mean": 0.034532,
+ "std": 0.001633,
+ "median": 0.034185,
+ "iqr": 0.000988,
+ "ci95_t": 0.002027
+ }
+ },
+ "120": {
+ "train_loss": {
+ "mean": 0.508942,
+ "std": 0.026551,
+ "median": 0.510971,
+ "iqr": 0.028057,
+ "ci95_t": 0.032967
+ },
+ "train_acc": {
+ "mean": 0.8452,
+ "std": 0.009712,
+ "median": 0.8465,
+ "iqr": 0.01,
+ "ci95_t": 0.012059
+ },
+ "train_mse": {
+ "mean": 0.022777,
+ "std": 0.001143,
+ "median": 0.022886,
+ "iqr": 0.000961,
+ "ci95_t": 0.00142
+ },
+ "test_loss": {
+ "mean": 0.68608,
+ "std": 0.033467,
+ "median": 0.672556,
+ "iqr": 0.046381,
+ "ci95_t": 0.041554
+ },
+ "test_acc": {
+ "mean": 0.7856,
+ "std": 0.00882,
+ "median": 0.789,
+ "iqr": 0.008,
+ "ci95_t": 0.010952
+ },
+ "test_mse": {
+ "mean": 0.030954,
+ "std": 0.001197,
+ "median": 0.030564,
+ "iqr": 0.001222,
+ "ci95_t": 0.001486
+ }
+ },
+ "140": {
+ "train_loss": {
+ "mean": 0.459063,
+ "std": 0.01503,
+ "median": 0.466831,
+ "iqr": 0.017175,
+ "ci95_t": 0.018662
+ },
+ "train_acc": {
+ "mean": 0.8621,
+ "std": 0.006475,
+ "median": 0.86,
+ "iqr": 0.009,
+ "ci95_t": 0.00804
+ },
+ "train_mse": {
+ "mean": 0.020458,
+ "std": 0.000767,
+ "median": 0.020908,
+ "iqr": 0.001208,
+ "ci95_t": 0.000953
+ },
+ "test_loss": {
+ "mean": 0.627599,
+ "std": 0.031053,
+ "median": 0.637535,
+ "iqr": 0.028389,
+ "ci95_t": 0.038557
+ },
+ "test_acc": {
+ "mean": 0.8034,
+ "std": 0.010213,
+ "median": 0.807,
+ "iqr": 0.013,
+ "ci95_t": 0.012681
+ },
+ "test_mse": {
+ "mean": 0.028692,
+ "std": 0.001263,
+ "median": 0.028759,
+ "iqr": 0.00115,
+ "ci95_t": 0.001568
+ }
+ },
+ "160": {
+ "train_loss": {
+ "mean": 0.426009,
+ "std": 0.011667,
+ "median": 0.430541,
+ "iqr": 0.00818,
+ "ci95_t": 0.014486
+ },
+ "train_acc": {
+ "mean": 0.8725,
+ "std": 0.004899,
+ "median": 0.872,
+ "iqr": 0.003,
+ "ci95_t": 0.006083
+ },
+ "train_mse": {
+ "mean": 0.019093,
+ "std": 0.00049,
+ "median": 0.019257,
+ "iqr": 0.000514,
+ "ci95_t": 0.000609
+ },
+ "test_loss": {
+ "mean": 0.599888,
+ "std": 0.027074,
+ "median": 0.603678,
+ "iqr": 0.040869,
+ "ci95_t": 0.033616
+ },
+ "test_acc": {
+ "mean": 0.8158,
+ "std": 0.011735,
+ "median": 0.817,
+ "iqr": 0.014,
+ "ci95_t": 0.01457
+ },
+ "test_mse": {
+ "mean": 0.027261,
+ "std": 0.001346,
+ "median": 0.026847,
+ "iqr": 0.001819,
+ "ci95_t": 0.001671
+ }
+ },
+ "180": {
+ "train_loss": {
+ "mean": 0.402343,
+ "std": 0.010144,
+ "median": 0.403393,
+ "iqr": 0.009695,
+ "ci95_t": 0.012595
+ },
+ "train_acc": {
+ "mean": 0.8787,
+ "std": 0.005275,
+ "median": 0.879,
+ "iqr": 0.0045,
+ "ci95_t": 0.00655
+ },
+ "train_mse": {
+ "mean": 0.017919,
+ "std": 0.000427,
+ "median": 0.01795,
+ "iqr": 0.00062,
+ "ci95_t": 0.00053
+ },
+ "test_loss": {
+ "mean": 0.575034,
+ "std": 0.018504,
+ "median": 0.568058,
+ "iqr": 0.020343,
+ "ci95_t": 0.022975
+ },
+ "test_acc": {
+ "mean": 0.8212,
+ "std": 0.004087,
+ "median": 0.82,
+ "iqr": 0.003,
+ "ci95_t": 0.005074
+ },
+ "test_mse": {
+ "mean": 0.026204,
+ "std": 0.000685,
+ "median": 0.026125,
+ "iqr": 0.000534,
+ "ci95_t": 0.000851
+ }
+ },
+ "200": {
+ "train_loss": {
+ "mean": 0.38532,
+ "std": 0.008996,
+ "median": 0.385098,
+ "iqr": 0.009554,
+ "ci95_t": 0.01117
+ },
+ "train_acc": {
+ "mean": 0.8866,
+ "std": 0.004336,
+ "median": 0.8865,
+ "iqr": 0.0025,
+ "ci95_t": 0.005384
+ },
+ "train_mse": {
+ "mean": 0.017241,
+ "std": 0.000375,
+ "median": 0.017122,
+ "iqr": 0.000663,
+ "ci95_t": 0.000466
+ },
+ "test_loss": {
+ "mean": 0.555652,
+ "std": 0.020276,
+ "median": 0.550887,
+ "iqr": 0.029173,
+ "ci95_t": 0.025176
+ },
+ "test_acc": {
+ "mean": 0.8258,
+ "std": 0.00638,
+ "median": 0.827,
+ "iqr": 0.008,
+ "ci95_t": 0.007921
+ },
+ "test_mse": {
+ "mean": 0.025541,
+ "std": 0.00079,
+ "median": 0.025581,
+ "iqr": 0.000543,
+ "ci95_t": 0.000981
+ }
+ },
+ "220": {
+ "train_loss": {
+ "mean": 0.371485,
+ "std": 0.009127,
+ "median": 0.372677,
+ "iqr": 0.009126,
+ "ci95_t": 0.011332
+ },
+ "train_acc": {
+ "mean": 0.8904,
+ "std": 0.005165,
+ "median": 0.89,
+ "iqr": 0.0075,
+ "ci95_t": 0.006413
+ },
+ "train_mse": {
+ "mean": 0.016631,
+ "std": 0.000491,
+ "median": 0.016703,
+ "iqr": 0.000868,
+ "ci95_t": 0.00061
+ },
+ "test_loss": {
+ "mean": 0.535477,
+ "std": 0.017871,
+ "median": 0.541238,
+ "iqr": 0.015327,
+ "ci95_t": 0.02219
+ },
+ "test_acc": {
+ "mean": 0.8308,
+ "std": 0.008044,
+ "median": 0.829,
+ "iqr": 0.012,
+ "ci95_t": 0.009987
+ },
+ "test_mse": {
+ "mean": 0.024718,
+ "std": 0.000769,
+ "median": 0.024624,
+ "iqr": 0.00053,
+ "ci95_t": 0.000955
+ }
+ },
+ "240": {
+ "train_loss": {
+ "mean": 0.359582,
+ "std": 0.009652,
+ "median": 0.360055,
+ "iqr": 0.009809,
+ "ci95_t": 0.011984
+ },
+ "train_acc": {
+ "mean": 0.8941,
+ "std": 0.005055,
+ "median": 0.8945,
+ "iqr": 0.009,
+ "ci95_t": 0.006276
+ },
+ "train_mse": {
+ "mean": 0.016111,
+ "std": 0.000476,
+ "median": 0.016138,
+ "iqr": 0.000803,
+ "ci95_t": 0.000591
+ },
+ "test_loss": {
+ "mean": 0.51582,
+ "std": 0.018827,
+ "median": 0.520115,
+ "iqr": 0.023442,
+ "ci95_t": 0.023377
+ },
+ "test_acc": {
+ "mean": 0.8352,
+ "std": 0.010521,
+ "median": 0.842,
+ "iqr": 0.012,
+ "ci95_t": 0.013064
+ },
+ "test_mse": {
+ "mean": 0.023741,
+ "std": 0.000893,
+ "median": 0.023789,
+ "iqr": 0.00137,
+ "ci95_t": 0.001109
+ }
+ }
+ },
+ "paired_deltas": {
+ "80_to_240": {
+ "train_loss_rel_reduction": {
+ "mean": 0.473028,
+ "std": 0.028737,
+ "median": 0.459271,
+ "iqr": 0.022395,
+ "ci95_t": 0.035681
+ },
+ "test_acc_delta": {
+ "mean": 0.1118,
+ "std": 0.012235,
+ "median": 0.112,
+ "iqr": 0.013,
+ "ci95_t": 0.015192
+ }
+ },
+ "200_to_240": {
+ "train_loss_rel_reduction": {
+ "mean": 0.066839,
+ "std": 0.006915,
+ "median": 0.069923,
+ "iqr": 0.006337,
+ "ci95_t": 0.008586
+ },
+ "test_acc_delta": {
+ "mean": 0.0094,
+ "std": 0.009965,
+ "median": 0.009,
+ "iqr": 0.01,
+ "ci95_t": 0.012373
+ },
+ "test_acc_abs_change": {
+ "mean": 0.0102,
+ "std": 0.008927,
+ "median": 0.009,
+ "iqr": 0.01,
+ "ci95_t": 0.011085
+ }
+ }
+ },
+ "paired_endpoint_deltas_by_seed": [
+ {
+ "seed": 71,
+ "train_loss_relative_reduction_80_to_240": 0.4540537153874719,
+ "test_accuracy_delta_80_to_240": 0.10600000619888306,
+ "train_loss_relative_reduction_200_to_240": 0.07136711819494895,
+ "test_accuracy_delta_200_to_240": 0.02399998903274536
+ },
+ {
+ "seed": 72,
+ "train_loss_relative_reduction_80_to_240": 0.476449094283263,
+ "test_accuracy_delta_80_to_240": 0.11900001764297485,
+ "train_loss_relative_reduction_200_to_240": 0.07233963777169808,
+ "test_accuracy_delta_200_to_240": 0.009000003337860107
+ },
+ {
+ "seed": 73,
+ "train_loss_relative_reduction_80_to_240": 0.5216889243761529,
+ "test_accuracy_delta_80_to_240": 0.12700003385543823,
+ "train_loss_relative_reduction_200_to_240": 0.06503036899387792,
+ "test_accuracy_delta_200_to_240": -0.001999974250793457
+ },
+ {
+ "seed": 74,
+ "train_loss_relative_reduction_80_to_240": 0.45927125150008824,
+ "test_accuracy_delta_80_to_240": 0.09499996900558472,
+ "train_loss_relative_reduction_200_to_240": 0.055537045315344924,
+ "test_accuracy_delta_200_to_240": 0.0029999613761901855
+ },
+ {
+ "seed": 75,
+ "train_loss_relative_reduction_80_to_240": 0.4536792796798996,
+ "test_accuracy_delta_80_to_240": 0.1119999885559082,
+ "train_loss_relative_reduction_200_to_240": 0.06992275073931131,
+ "test_accuracy_delta_200_to_240": 0.013000011444091797
+ }
+ ],
+ "last_training_best_improvement_epochs": {
+ "71": 240,
+ "72": 240,
+ "73": 240,
+ "74": 239,
+ "75": 240
+ }
+ },
+ "runs": [
+ {
+ "seed": 71,
+ "model_fingerprint": "0777bd52fd76272d",
+ "expected_model_fingerprint": "0777bd52fd76272d",
+ "fingerprint_matched": true,
+ "baseline_epoch80_test_acc": 0.7360000014305115,
+ "epoch80_test_acc": 0.7360000014305115,
+ "epoch80_abs_delta": 0.0,
+ "fit_time_sec": 32.5467,
+ "improvement_count": 235,
+ "last_improvement_epoch": 240,
+ "checkpoints": [
+ {
+ "epoch": 20,
+ "train_loss": 1.5967158079147339,
+ "train_acc": 0.4830000102519989,
+ "train_mse": 0.0660470575094223,
+ "test_loss": 1.7100492715835571,
+ "test_acc": 0.43799999356269836,
+ "test_mse": 0.07075551897287369
+ },
+ {
+ "epoch": 40,
+ "train_loss": 1.1239886283874512,
+ "train_acc": 0.6434999704360962,
+ "train_mse": 0.04822305589914322,
+ "test_loss": 1.3276519775390625,
+ "test_acc": 0.578000009059906,
+ "test_mse": 0.05614830181002617
+ },
+ {
+ "epoch": 60,
+ "train_loss": 0.8301568627357483,
+ "train_acc": 0.7429999709129333,
+ "train_mse": 0.03629826754331589,
+ "test_loss": 1.0045816898345947,
+ "test_acc": 0.6800000071525574,
+ "test_mse": 0.04412851482629776
+ },
+ {
+ "epoch": 80,
+ "train_loss": 0.6516683101654053,
+ "train_acc": 0.7950000166893005,
+ "train_mse": 0.028850017115473747,
+ "test_loss": 0.8584634065628052,
+ "test_acc": 0.7360000014305115,
+ "test_mse": 0.037673790007829666
+ },
+ {
+ "epoch": 100,
+ "train_loss": 0.5542685985565186,
+ "train_acc": 0.824999988079071,
+ "train_mse": 0.024905934929847717,
+ "test_loss": 0.7590173482894897,
+ "test_acc": 0.7620000243186951,
+ "test_mse": 0.03418450802564621
+ },
+ {
+ "epoch": 120,
+ "train_loss": 0.49202004075050354,
+ "train_acc": 0.8399999737739563,
+ "train_mse": 0.021997792646288872,
+ "test_loss": 0.7061744332313538,
+ "test_acc": 0.7889999747276306,
+ "test_mse": 0.03144212067127228
+ },
+ {
+ "epoch": 140,
+ "train_loss": 0.45162707567214966,
+ "train_acc": 0.8665000200271606,
+ "train_mse": 0.01984463632106781,
+ "test_loss": 0.6375347971916199,
+ "test_acc": 0.796999990940094,
+ "test_mse": 0.029180902987718582
+ },
+ {
+ "epoch": 160,
+ "train_loss": 0.4246227741241455,
+ "train_acc": 0.8740000128746033,
+ "train_mse": 0.018856780603528023,
+ "test_loss": 0.6248053312301636,
+ "test_acc": 0.8009999990463257,
+ "test_mse": 0.028511321172118187
+ },
+ {
+ "epoch": 180,
+ "train_loss": 0.39958131313323975,
+ "train_acc": 0.8799999952316284,
+ "train_mse": 0.01768091320991516,
+ "test_loss": 0.6031026244163513,
+ "test_acc": 0.8159999847412109,
+ "test_mse": 0.027248937636613846
+ },
+ {
+ "epoch": 200,
+ "train_loss": 0.3831179141998291,
+ "train_acc": 0.8924999833106995,
+ "train_mse": 0.016940467059612274,
+ "test_loss": 0.5841547846794128,
+ "test_acc": 0.8180000185966492,
+ "test_mse": 0.026774849742650986
+ },
+ {
+ "epoch": 220,
+ "train_loss": 0.36869707703590393,
+ "train_acc": 0.8970000147819519,
+ "train_mse": 0.016194477677345276,
+ "test_loss": 0.5548750162124634,
+ "test_acc": 0.8259999752044678,
+ "test_mse": 0.025661807507276535
+ },
+ {
+ "epoch": 240,
+ "train_loss": 0.3557758927345276,
+ "train_acc": 0.8989999890327454,
+ "train_mse": 0.015656106173992157,
+ "test_loss": 0.5201151371002197,
+ "test_acc": 0.8420000076293945,
+ "test_mse": 0.023789195343852043
+ }
+ ]
+ },
+ {
+ "seed": 72,
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "expected_model_fingerprint": "6fcb6e473bdacbd2",
+ "fingerprint_matched": true,
+ "baseline_epoch80_test_acc": 0.7239999771118164,
+ "epoch80_test_acc": 0.7239999771118164,
+ "epoch80_abs_delta": 0.0,
+ "fit_time_sec": 32.606,
+ "improvement_count": 231,
+ "last_improvement_epoch": 240,
+ "checkpoints": [
+ {
+ "epoch": 20,
+ "train_loss": 1.673862338066101,
+ "train_acc": 0.46149998903274536,
+ "train_mse": 0.0692000463604927,
+ "test_loss": 1.8141505718231201,
+ "test_acc": 0.4099999964237213,
+ "test_mse": 0.07267315685749054
+ },
+ {
+ "epoch": 40,
+ "train_loss": 1.1490310430526733,
+ "train_acc": 0.6324999928474426,
+ "train_mse": 0.04914539307355881,
+ "test_loss": 1.372908592224121,
+ "test_acc": 0.5709999799728394,
+ "test_mse": 0.05662866309285164
+ },
+ {
+ "epoch": 60,
+ "train_loss": 0.8807169198989868,
+ "train_acc": 0.7369999885559082,
+ "train_mse": 0.03719912841916084,
+ "test_loss": 1.1267516613006592,
+ "test_acc": 0.6420000195503235,
+ "test_mse": 0.04854830726981163
+ },
+ {
+ "epoch": 80,
+ "train_loss": 0.6982801556587219,
+ "train_acc": 0.7914999723434448,
+ "train_mse": 0.030153820291161537,
+ "test_loss": 0.9025362133979797,
+ "test_acc": 0.7239999771118164,
+ "test_mse": 0.038956169039011
+ },
+ {
+ "epoch": 100,
+ "train_loss": 0.5910305380821228,
+ "train_acc": 0.8165000081062317,
+ "train_mse": 0.026041019707918167,
+ "test_loss": 0.7481632232666016,
+ "test_acc": 0.7570000290870667,
+ "test_mse": 0.03314316272735596
+ },
+ {
+ "epoch": 120,
+ "train_loss": 0.5200771689414978,
+ "train_acc": 0.8464999794960022,
+ "train_mse": 0.022959064692258835,
+ "test_loss": 0.6597934365272522,
+ "test_acc": 0.7889999747276306,
+ "test_mse": 0.029753563925623894
+ },
+ {
+ "epoch": 140,
+ "train_loss": 0.4719507694244385,
+ "train_acc": 0.8554999828338623,
+ "train_mse": 0.020908480510115623,
+ "test_loss": 0.58547043800354,
+ "test_acc": 0.8100000023841858,
+ "test_mse": 0.02705816738307476
+ },
+ {
+ "epoch": 160,
+ "train_loss": 0.4356405735015869,
+ "train_acc": 0.871999979019165,
+ "train_mse": 0.019257094711065292,
+ "test_loss": 0.583936333656311,
+ "test_acc": 0.8220000267028809,
+ "test_mse": 0.026691943407058716
+ },
+ {
+ "epoch": 180,
+ "train_loss": 0.4127918779850006,
+ "train_acc": 0.8725000023841858,
+ "train_mse": 0.018300892785191536,
+ "test_loss": 0.5632762312889099,
+ "test_acc": 0.8199999928474426,
+ "test_mse": 0.025847580283880234
+ },
+ {
+ "epoch": 200,
+ "train_loss": 0.3940938115119934,
+ "train_acc": 0.8805000185966492,
+ "train_mse": 0.017671920359134674,
+ "test_loss": 0.5363063216209412,
+ "test_acc": 0.8339999914169312,
+ "test_mse": 0.024680841714143753
+ },
+ {
+ "epoch": 220,
+ "train_loss": 0.37782323360443115,
+ "train_acc": 0.8845000267028809,
+ "train_mse": 0.017062701284885406,
+ "test_loss": 0.508123517036438,
+ "test_acc": 0.8399999737739563,
+ "test_mse": 0.023583590984344482
+ },
+ {
+ "epoch": 240,
+ "train_loss": 0.36558520793914795,
+ "train_acc": 0.8899999856948853,
+ "train_mse": 0.01645873300731182,
+ "test_loss": 0.49120959639549255,
+ "test_acc": 0.8429999947547913,
+ "test_mse": 0.022604094818234444
+ }
+ ]
+ },
+ {
+ "seed": 73,
+ "model_fingerprint": "2e6c351372592f10",
+ "expected_model_fingerprint": "2e6c351372592f10",
+ "fingerprint_matched": true,
+ "baseline_epoch80_test_acc": 0.6919999718666077,
+ "epoch80_test_acc": 0.6919999718666077,
+ "epoch80_abs_delta": 0.0,
+ "fit_time_sec": 32.7255,
+ "improvement_count": 233,
+ "last_improvement_epoch": 240,
+ "checkpoints": [
+ {
+ "epoch": 20,
+ "train_loss": 1.7135908603668213,
+ "train_acc": 0.4449999928474426,
+ "train_mse": 0.07240503281354904,
+ "test_loss": 1.8838708400726318,
+ "test_acc": 0.375,
+ "test_mse": 0.0778227150440216
+ },
+ {
+ "epoch": 40,
+ "train_loss": 1.2155654430389404,
+ "train_acc": 0.6340000033378601,
+ "train_mse": 0.051504913717508316,
+ "test_loss": 1.4863072633743286,
+ "test_acc": 0.5569999814033508,
+ "test_mse": 0.06111995875835419
+ },
+ {
+ "epoch": 60,
+ "train_loss": 0.9407793283462524,
+ "train_acc": 0.722000002861023,
+ "train_mse": 0.03982725366950035,
+ "test_loss": 1.1702646017074585,
+ "test_acc": 0.6439999938011169,
+ "test_mse": 0.049435749650001526
+ },
+ {
+ "epoch": 80,
+ "train_loss": 0.7527623772621155,
+ "train_acc": 0.7749999761581421,
+ "train_mse": 0.032556530088186264,
+ "test_loss": 1.001193642616272,
+ "test_acc": 0.6919999718666077,
+ "test_mse": 0.04309915751218796
+ },
+ {
+ "epoch": 100,
+ "train_loss": 0.6268301606178284,
+ "train_acc": 0.8140000104904175,
+ "train_mse": 0.027759678661823273,
+ "test_loss": 0.8296219706535339,
+ "test_acc": 0.7319999933242798,
+ "test_mse": 0.03728931397199631
+ },
+ {
+ "epoch": 120,
+ "train_loss": 0.5454505681991577,
+ "train_acc": 0.8320000171661377,
+ "train_mse": 0.02451479621231556,
+ "test_loss": 0.7347204089164734,
+ "test_acc": 0.7730000019073486,
+ "test_mse": 0.03278779238462448
+ },
+ {
+ "epoch": 140,
+ "train_loss": 0.46880221366882324,
+ "train_acc": 0.8575000166893005,
+ "train_mse": 0.021052677184343338,
+ "test_loss": 0.6670262813568115,
+ "test_acc": 0.7889999747276306,
+ "test_mse": 0.030432477593421936
+ },
+ {
+ "epoch": 160,
+ "train_loss": 0.43280255794525146,
+ "train_acc": 0.8659999966621399,
+ "train_mse": 0.01961500570178032,
+ "test_loss": 0.6248233914375305,
+ "test_acc": 0.8080000281333923,
+ "test_mse": 0.028731103986501694
+ },
+ {
+ "epoch": 180,
+ "train_loss": 0.4033927321434021,
+ "train_acc": 0.8790000081062317,
+ "train_mse": 0.017949724569916725,
+ "test_loss": 0.5680584907531738,
+ "test_acc": 0.8230000138282776,
+ "test_mse": 0.02612500637769699
+ },
+ {
+ "epoch": 200,
+ "train_loss": 0.3850976228713989,
+ "train_acc": 0.8880000114440918,
+ "train_mse": 0.017122117802500725,
+ "test_loss": 0.5508874654769897,
+ "test_acc": 0.8209999799728394,
+ "test_mse": 0.025604458525776863
+ },
+ {
+ "epoch": 220,
+ "train_loss": 0.3726767599582672,
+ "train_acc": 0.8899999856948853,
+ "train_mse": 0.016703158617019653,
+ "test_loss": 0.5412379503250122,
+ "test_acc": 0.8209999799728394,
+ "test_mse": 0.025124624371528625
+ },
+ {
+ "epoch": 240,
+ "train_loss": 0.3600545823574066,
+ "train_acc": 0.8989999890327454,
+ "train_mse": 0.016138451173901558,
+ "test_loss": 0.5263404250144958,
+ "test_acc": 0.8190000057220459,
+ "test_mse": 0.024716168642044067
+ }
+ ]
+ },
+ {
+ "seed": 74,
+ "model_fingerprint": "4000fe3fb26ef207",
+ "expected_model_fingerprint": "4000fe3fb26ef207",
+ "fingerprint_matched": true,
+ "baseline_epoch80_test_acc": 0.7350000143051147,
+ "epoch80_test_acc": 0.7350000143051147,
+ "epoch80_abs_delta": 0.0,
+ "fit_time_sec": 32.9017,
+ "improvement_count": 233,
+ "last_improvement_epoch": 239,
+ "checkpoints": [
+ {
+ "epoch": 20,
+ "train_loss": 1.5981744527816772,
+ "train_acc": 0.49950000643730164,
+ "train_mse": 0.06673180311918259,
+ "test_loss": 1.7434691190719604,
+ "test_acc": 0.42399999499320984,
+ "test_mse": 0.07240629941225052
+ },
+ {
+ "epoch": 40,
+ "train_loss": 1.1163724660873413,
+ "train_acc": 0.6600000262260437,
+ "train_mse": 0.047663308680057526,
+ "test_loss": 1.2812504768371582,
+ "test_acc": 0.6079999804496765,
+ "test_mse": 0.05496295168995857
+ },
+ {
+ "epoch": 60,
+ "train_loss": 0.8247233629226685,
+ "train_acc": 0.7429999709129333,
+ "train_mse": 0.03677733987569809,
+ "test_loss": 0.996366560459137,
+ "test_acc": 0.6800000071525574,
+ "test_mse": 0.044562000781297684
+ },
+ {
+ "epoch": 80,
+ "train_loss": 0.6858600974082947,
+ "train_acc": 0.784500002861023,
+ "train_mse": 0.030640259385108948,
+ "test_loss": 0.8601324558258057,
+ "test_acc": 0.7350000143051147,
+ "test_mse": 0.03845023736357689
+ },
+ {
+ "epoch": 100,
+ "train_loss": 0.5762760043144226,
+ "train_acc": 0.8274999856948853,
+ "train_mse": 0.025603292509913445,
+ "test_loss": 0.7484227418899536,
+ "test_acc": 0.7580000162124634,
+ "test_mse": 0.03352699801325798
+ },
+ {
+ "epoch": 120,
+ "train_loss": 0.5109706521034241,
+ "train_acc": 0.8500000238418579,
+ "train_mse": 0.02288639359176159,
+ "test_loss": 0.6725562810897827,
+ "test_acc": 0.7960000038146973,
+ "test_mse": 0.030220312997698784
+ },
+ {
+ "epoch": 140,
+ "train_loss": 0.4668312966823578,
+ "train_acc": 0.8600000143051147,
+ "train_mse": 0.021057307720184326,
+ "test_loss": 0.6381762623786926,
+ "test_acc": 0.8069999814033508,
+ "test_mse": 0.028759241104125977
+ },
+ {
+ "epoch": 160,
+ "train_loss": 0.430540531873703,
+ "train_acc": 0.8709999918937683,
+ "train_mse": 0.01937052235007286,
+ "test_loss": 0.6036783456802368,
+ "test_acc": 0.8169999718666077,
+ "test_mse": 0.026846695691347122
+ },
+ {
+ "epoch": 180,
+ "train_loss": 0.4092761278152466,
+ "train_acc": 0.8755000233650208,
+ "train_mse": 0.018336936831474304,
+ "test_loss": 0.5836188793182373,
+ "test_acc": 0.8199999928474426,
+ "test_mse": 0.0263815987855196
+ },
+ {
+ "epoch": 200,
+ "train_loss": 0.3926721215248108,
+ "train_acc": 0.8865000009536743,
+ "train_mse": 0.017603637650609016,
+ "test_loss": 0.5680423378944397,
+ "test_acc": 0.8270000219345093,
+ "test_mse": 0.02558077871799469
+ },
+ {
+ "epoch": 220,
+ "train_loss": 0.38078930974006653,
+ "train_acc": 0.8865000009536743,
+ "train_mse": 0.017137007787823677,
+ "test_loss": 0.5442376136779785,
+ "test_acc": 0.8379999995231628,
+ "test_mse": 0.024594470858573914
+ },
+ {
+ "epoch": 240,
+ "train_loss": 0.37086427211761475,
+ "train_acc": 0.8880000114440918,
+ "train_mse": 0.016686489805579185,
+ "test_loss": 0.5385385155677795,
+ "test_acc": 0.8299999833106995,
+ "test_mse": 0.024481549859046936
+ }
+ ]
+ },
+ {
+ "seed": 75,
+ "model_fingerprint": "0966039f5ef7af88",
+ "expected_model_fingerprint": "0966039f5ef7af88",
+ "fingerprint_matched": true,
+ "baseline_epoch80_test_acc": 0.7300000190734863,
+ "epoch80_test_acc": 0.7300000190734863,
+ "epoch80_abs_delta": 0.0,
+ "fit_time_sec": 32.7233,
+ "improvement_count": 232,
+ "last_improvement_epoch": 240,
+ "checkpoints": [
+ {
+ "epoch": 20,
+ "train_loss": 1.635738730430603,
+ "train_acc": 0.46950000524520874,
+ "train_mse": 0.06960180401802063,
+ "test_loss": 1.8486356735229492,
+ "test_acc": 0.4059999883174896,
+ "test_mse": 0.07580890506505966
+ },
+ {
+ "epoch": 40,
+ "train_loss": 1.0605015754699707,
+ "train_acc": 0.6604999899864197,
+ "train_mse": 0.04849516972899437,
+ "test_loss": 1.2981681823730469,
+ "test_acc": 0.5630000233650208,
+ "test_mse": 0.05867462605237961
+ },
+ {
+ "epoch": 60,
+ "train_loss": 0.7738548517227173,
+ "train_acc": 0.7615000009536743,
+ "train_mse": 0.03458299860358238,
+ "test_loss": 1.0294034481048584,
+ "test_acc": 0.671999990940094,
+ "test_mse": 0.04577324911952019
+ },
+ {
+ "epoch": 80,
+ "train_loss": 0.6326538324356079,
+ "train_acc": 0.8125,
+ "train_mse": 0.02839995175600052,
+ "test_loss": 0.889915406703949,
+ "test_acc": 0.7300000190734863,
+ "test_mse": 0.03931796923279762
+ },
+ {
+ "epoch": 100,
+ "train_loss": 0.529951810836792,
+ "train_acc": 0.8370000123977661,
+ "train_mse": 0.02384800836443901,
+ "test_loss": 0.762531042098999,
+ "test_acc": 0.7620000243186951,
+ "test_mse": 0.034515053033828735
+ },
+ {
+ "epoch": 120,
+ "train_loss": 0.47619307041168213,
+ "train_acc": 0.8575000166893005,
+ "train_mse": 0.021528739482164383,
+ "test_loss": 0.6571563482284546,
+ "test_acc": 0.781000018119812,
+ "test_mse": 0.030564110726118088
+ },
+ {
+ "epoch": 140,
+ "train_loss": 0.43610602617263794,
+ "train_acc": 0.8709999918937683,
+ "train_mse": 0.019426772370934486,
+ "test_loss": 0.6097874641418457,
+ "test_acc": 0.8140000104904175,
+ "test_mse": 0.028030628338456154
+ },
+ {
+ "epoch": 160,
+ "train_loss": 0.4064372479915619,
+ "train_acc": 0.8794999718666077,
+ "train_mse": 0.01836566999554634,
+ "test_loss": 0.5621976256370544,
+ "test_acc": 0.8309999704360962,
+ "test_mse": 0.025522591546177864
+ },
+ {
+ "epoch": 180,
+ "train_loss": 0.3866714835166931,
+ "train_acc": 0.8865000009536743,
+ "train_mse": 0.01732715405523777,
+ "test_loss": 0.557114839553833,
+ "test_acc": 0.8270000219345093,
+ "test_mse": 0.025415310636162758
+ },
+ {
+ "epoch": 200,
+ "train_loss": 0.37161633372306824,
+ "train_acc": 0.8855000138282776,
+ "train_mse": 0.016865627840161324,
+ "test_loss": 0.5388693809509277,
+ "test_acc": 0.8289999961853027,
+ "test_mse": 0.025061823427677155
+ },
+ {
+ "epoch": 220,
+ "train_loss": 0.3574405014514923,
+ "train_acc": 0.8939999938011169,
+ "train_mse": 0.016058821231126785,
+ "test_loss": 0.528910756111145,
+ "test_acc": 0.8289999961853027,
+ "test_mse": 0.024624072015285492
+ },
+ {
+ "epoch": 240,
+ "train_loss": 0.3456318974494934,
+ "train_acc": 0.8945000171661377,
+ "train_mse": 0.0156160369515419,
+ "test_loss": 0.5028988122940063,
+ "test_acc": 0.8420000076293945,
+ "test_mse": 0.023111792281270027
+ }
+ ]
+ }
+ ],
+ "completed": true,
+ "valid": true,
+ "error": null
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v4_full_mnist.csv b/benchmark_results/pso_v4_full_mnist.csv
new file mode 100644
index 0000000..a02a41c
--- /dev/null
+++ b/benchmark_results/pso_v4_full_mnist.csv
@@ -0,0 +1,61 @@
+seed,epoch,train_loss,train_acc,train_mse,test_loss,test_acc,test_mse,fit_time_sec
+71,20,1.6637481451034546,0.4778333306312561,0.06879015266895294,1.6244964599609375,0.4961000084877014,0.0671548843383789,33.649
+71,40,1.165610432624817,0.6545166373252869,0.04875154793262482,1.0854827165603638,0.6718000173568726,0.046549420803785324,33.649
+71,60,0.905483067035675,0.7269166707992554,0.0389271154999733,0.8291375041007996,0.7445999979972839,0.036550913006067276,33.649
+71,80,0.7415720224380493,0.7783499956130981,0.03182263299822807,0.6753337979316711,0.7944999933242798,0.029618915170431137,33.649
+71,100,0.6563442945480347,0.8064000010490417,0.02799912355840206,0.5993074178695679,0.8216999769210815,0.025761328637599945,33.649
+71,120,0.588559091091156,0.8279500007629395,0.025105126202106476,0.5335480570793152,0.8414999842643738,0.022965701296925545,33.649
+71,140,0.5534469485282898,0.8387500047683716,0.023768901824951172,0.5105180144309998,0.8489999771118164,0.022098202258348465,33.649
+71,160,0.5169084668159485,0.8464000225067139,0.022431854158639908,0.4750884771347046,0.8555999994277954,0.02082662656903267,33.649
+71,180,0.48863890767097473,0.8547000288963318,0.021347153931856155,0.4477296769618988,0.8686000108718872,0.01953563280403614,33.649
+71,200,0.4686008393764496,0.8610333204269409,0.020526422187685966,0.43183833360671997,0.8719000220298767,0.018971838057041168,33.649
+71,220,0.45222264528274536,0.8653833270072937,0.0198610108345747,0.4211212396621704,0.8756999969482422,0.01851881667971611,33.649
+71,240,0.438436359167099,0.8698999881744385,0.019294776022434235,0.41157108545303345,0.878000020980835,0.018099937587976456,33.649
+72,20,1.7392971515655518,0.4580833315849304,0.07111531496047974,1.7067090272903442,0.4602999985218048,0.07063549011945724,33.7062
+72,40,1.2618558406829834,0.6182666420936584,0.05362313985824585,1.2296088933944702,0.6273000240325928,0.05239206552505493,33.7062
+72,60,0.9506728053092957,0.7125833630561829,0.04073568433523178,0.90444415807724,0.725600004196167,0.03892349451780319,33.7062
+72,80,0.7690414786338806,0.7677000164985657,0.0332583524286747,0.7225316762924194,0.7825000286102295,0.03151436522603035,33.7062
+72,100,0.6607407331466675,0.7977833151817322,0.029053399339318275,0.6213417053222656,0.8091999888420105,0.02738099917769432,33.7062
+72,120,0.5884125232696533,0.8225333094596863,0.02557925134897232,0.5514547824859619,0.8324999809265137,0.024056605994701385,33.7062
+72,140,0.5509796142578125,0.8328999876976013,0.02395990863442421,0.5114421844482422,0.8463000059127808,0.022018717601895332,33.7062
+72,160,0.5122449398040771,0.8464499711990356,0.022468935698270798,0.4830068349838257,0.8574000000953674,0.021029997617006302,33.7062
+72,180,0.4828203022480011,0.8543833494186401,0.021225325763225555,0.45465460419654846,0.8646000027656555,0.01990104280412197,33.7062
+72,200,0.46293872594833374,0.8621000051498413,0.020341966301202774,0.4369881749153137,0.8700000047683716,0.019186409190297127,33.7062
+72,220,0.4459497630596161,0.8664166927337646,0.0197211392223835,0.41942450404167175,0.8730000257492065,0.0184775423258543,33.7062
+72,240,0.4350419342517853,0.871566653251648,0.01916772872209549,0.41060513257980347,0.875,0.018150048330426216,33.7062
+73,20,1.703110694885254,0.4322333335876465,0.07236693799495697,1.662993311882019,0.4422999918460846,0.07139508426189423,33.0256
+73,40,1.234723448753357,0.605400025844574,0.05369972065091133,1.2019942998886108,0.6128000020980835,0.05271701514720917,33.0256
+73,60,0.9583781361579895,0.7071499824523926,0.04126281663775444,0.9148314595222473,0.7215999960899353,0.03978179767727852,33.0256
+73,80,0.781466543674469,0.7578666806221008,0.034513432532548904,0.7499686479568481,0.7670999765396118,0.03327890485525131,33.0256
+73,100,0.6772935390472412,0.7944999933242798,0.029873577877879143,0.6402292251586914,0.8046000003814697,0.02839311771094799,33.0256
+73,120,0.6110365986824036,0.8133666515350342,0.027105839923024178,0.5728253722190857,0.821399986743927,0.02574964240193367,33.0256
+73,140,0.5631463527679443,0.8302500247955322,0.024875810369849205,0.5334057807922363,0.8353999853134155,0.023713810369372368,33.0256
+73,160,0.5311679840087891,0.8410833477973938,0.023450637236237526,0.501768171787262,0.8464000225067139,0.022286171093583107,33.0256
+73,180,0.5000290870666504,0.8493833541870117,0.022157883271574974,0.4740225672721863,0.8550000190734863,0.021153515204787254,33.0256
+73,200,0.48113930225372314,0.8564833402633667,0.02121545933187008,0.4526425898075104,0.8634999990463257,0.020089736208319664,33.0256
+73,220,0.46380415558815,0.8618666529655457,0.020463503897190094,0.4359147846698761,0.8684999942779541,0.019339669495821,33.0256
+73,240,0.449687123298645,0.8664166927337646,0.019846484065055847,0.4234127998352051,0.8718000054359436,0.018784264102578163,33.0256
+74,20,1.696816325187683,0.4334833323955536,0.07303200662136078,1.685478925704956,0.4397999942302704,0.07274489104747772,32.3565
+74,40,1.2137997150421143,0.6062666773796082,0.053883783519268036,1.193790316581726,0.6158999800682068,0.05286615714430809,32.3565
+74,60,0.9459328651428223,0.7093166708946228,0.04073885455727577,0.926419734954834,0.7172999978065491,0.03994119539856911,32.3565
+74,80,0.7440351843833923,0.7731500267982483,0.03230465576052666,0.7158955335617065,0.7832000255584717,0.0311629269272089,32.3565
+74,100,0.6222507357597351,0.8106666803359985,0.02721019648015499,0.5782299041748047,0.826200008392334,0.025308359414339066,32.3565
+74,120,0.5712149143218994,0.8261666893959045,0.025098947808146477,0.5316479206085205,0.8402000069618225,0.023361243307590485,32.3565
+74,140,0.5278127193450928,0.8391500115394592,0.02332845889031887,0.5003852248191833,0.8485000133514404,0.022033091634511948,32.3565
+74,160,0.4974406957626343,0.8500166535377502,0.02210366539657116,0.4702143669128418,0.8614000082015991,0.02081647887825966,32.3565
+74,180,0.4760556221008301,0.8567833304405212,0.0210970938205719,0.4514496922492981,0.8648999929428101,0.01998041942715645,32.3565
+74,200,0.4600929617881775,0.8631166815757751,0.020222675055265427,0.43229734897613525,0.8694999814033508,0.01901264674961567,32.3565
+74,220,0.44254931807518005,0.8678500056266785,0.019469955936074257,0.417081743478775,0.8754000067710876,0.018321329727768898,32.3565
+74,240,0.43052077293395996,0.8725666403770447,0.018974633887410164,0.40485620498657227,0.8798999786376953,0.01778729446232319,32.3565
+75,20,1.7082723379135132,0.42640000581741333,0.07211916148662567,1.6778934001922607,0.43220001459121704,0.07167963683605194,33.1184
+75,40,1.2474853992462158,0.628333330154419,0.05103134736418724,1.1880637407302856,0.6402000188827515,0.04922466725111008,33.1184
+75,60,0.9827106595039368,0.7029333114624023,0.041922468692064285,0.9340476393699646,0.7074000239372253,0.040672920644283295,33.1184
+75,80,0.8061239719390869,0.7508833408355713,0.035569027066230774,0.7613834738731384,0.7562999725341797,0.03404615819454193,33.1184
+75,100,0.6677705645561218,0.7959833145141602,0.029427148401737213,0.6365524530410767,0.8015999794006348,0.027956314384937286,33.1184
+75,120,0.5898874998092651,0.8204500079154968,0.025896690785884857,0.5661898255348206,0.8285999894142151,0.024743687361478806,33.1184
+75,140,0.5386065244674683,0.8367666602134705,0.023783763870596886,0.5188254714012146,0.8396999835968018,0.022942783311009407,33.1184
+75,160,0.5006535053253174,0.8497833609580994,0.022141018882393837,0.48212501406669617,0.8569999933242798,0.021169248968362808,33.1184
+75,180,0.47602227330207825,0.8565999865531921,0.021099673584103584,0.45692178606987,0.861299991607666,0.020099563524127007,33.1184
+75,200,0.4532005488872528,0.8648999929428101,0.020130231976509094,0.4406105577945709,0.8676999807357788,0.019379951059818268,33.1184
+75,220,0.4393870532512665,0.8705000281333923,0.019430004060268402,0.42279207706451416,0.8766999840736389,0.018535815179347992,33.1184
+75,240,0.4296344220638275,0.8724499940872192,0.019024165347218513,0.40994536876678467,0.8802000284194946,0.01800552010536194,33.1184
diff --git a/benchmark_results/pso_v4_full_mnist.json b/benchmark_results/pso_v4_full_mnist.json
new file mode 100644
index 0000000..100949f
--- /dev/null
+++ b/benchmark_results/pso_v4_full_mnist.json
@@ -0,0 +1,8912 @@
+{
+ "full_mnist_protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "device": "mps",
+ "timestamp": "2026-09-02 00:16:58",
+ "baseline_path": "benchmark_results/pso_v4_tuning.json",
+ "subset_study_path": "benchmark_results/pso_v4_epoch_convergence.json",
+ "sample_counts": {
+ "train_samples": 60000,
+ "test_samples": 10000
+ },
+ "pca_provenance": {
+ "n_components": 32,
+ "whiten": true,
+ "random_state": 42,
+ "fit_scope": "official_train_split_60000_only",
+ "train_samples_fit": 60000,
+ "test_samples_transformed": 10000,
+ "explained_variance_ratio_sum": 0.743599534034729
+ },
+ "data_fingerprint": "3586f0b2d63ab546",
+ "fitness_evaluation_contract": {
+ "selector": "full",
+ "fitness_size": null,
+ "train_samples_per_particle_per_epoch": 60000,
+ "particle_evaluations": 144000,
+ "particle_sample_evaluations": 8640000000,
+ "test_samples_per_checkpoint": 10000
+ },
+ "candidate_label": "am_b0.06_s0.5",
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "full",
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 240,
+ "batch_size": 60000,
+ "renewal": "loss",
+ "checkpoint_interval": 20
+ },
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "timing_scope": "fit_only_after_full-evaluation_two-epoch_warmup",
+ "diagnostics": {
+ "post80_train_improvement_pct": 0.431759,
+ "post80_train_improvement_passed": true,
+ "epoch240_test_gain": 0.10026,
+ "epoch240_test_gain_passed": true,
+ "late_plateau_200_240": false,
+ "late_plateau_train_loss_rel_reduction_200_240": 0.061329,
+ "late_plateau_test_acc_abs_change_200_240": 0.00846
+ },
+ "descriptive_subset_comparison": {
+ "subset_study_path": "benchmark_results/pso_v4_epoch_convergence.json",
+ "disclaimer": "The full and subset studies optimize different training objectives and the evaluation plugin changes RNG consumption (all 60,000 train samples versus a fixed 2,000-sample fitness subset). Matching-seed and matching-epoch comparisons are descriptive, not an exact paired causal isolation.",
+ "matching_epoch_deltas": {
+ "20": {
+ "full_mnist_train_loss_mean": 1.702249,
+ "subset_study_train_loss_mean": 1.643616,
+ "train_loss_delta_full_minus_subset": 0.058633,
+ "full_mnist_test_acc_mean": 0.45414,
+ "subset_study_test_acc_mean": 0.4106,
+ "test_acc_delta_full_minus_subset": 0.04354
+ },
+ "40": {
+ "full_mnist_train_loss_mean": 1.224695,
+ "subset_study_train_loss_mean": 1.133092,
+ "train_loss_delta_full_minus_subset": 0.091603,
+ "full_mnist_test_acc_mean": 0.6336,
+ "subset_study_test_acc_mean": 0.5754,
+ "test_acc_delta_full_minus_subset": 0.0582
+ },
+ "60": {
+ "full_mnist_train_loss_mean": 0.948636,
+ "subset_study_train_loss_mean": 0.850046,
+ "train_loss_delta_full_minus_subset": 0.09859,
+ "full_mnist_test_acc_mean": 0.7233,
+ "subset_study_test_acc_mean": 0.6636,
+ "test_acc_delta_full_minus_subset": 0.0597
+ },
+ "80": {
+ "full_mnist_train_loss_mean": 0.768448,
+ "subset_study_train_loss_mean": 0.684245,
+ "train_loss_delta_full_minus_subset": 0.084203,
+ "full_mnist_test_acc_mean": 0.77672,
+ "subset_study_test_acc_mean": 0.7234,
+ "test_acc_delta_full_minus_subset": 0.05332
+ },
+ "100": {
+ "full_mnist_train_loss_mean": 0.65688,
+ "subset_study_train_loss_mean": 0.575671,
+ "train_loss_delta_full_minus_subset": 0.081209,
+ "full_mnist_test_acc_mean": 0.81266,
+ "subset_study_test_acc_mean": 0.7542,
+ "test_acc_delta_full_minus_subset": 0.05846
+ },
+ "120": {
+ "full_mnist_train_loss_mean": 0.589822,
+ "subset_study_train_loss_mean": 0.508942,
+ "train_loss_delta_full_minus_subset": 0.08088,
+ "full_mnist_test_acc_mean": 0.83284,
+ "subset_study_test_acc_mean": 0.7856,
+ "test_acc_delta_full_minus_subset": 0.04724
+ },
+ "140": {
+ "full_mnist_train_loss_mean": 0.546798,
+ "subset_study_train_loss_mean": 0.459063,
+ "train_loss_delta_full_minus_subset": 0.087735,
+ "full_mnist_test_acc_mean": 0.84378,
+ "subset_study_test_acc_mean": 0.8034,
+ "test_acc_delta_full_minus_subset": 0.04038
+ },
+ "160": {
+ "full_mnist_train_loss_mean": 0.511683,
+ "subset_study_train_loss_mean": 0.426009,
+ "train_loss_delta_full_minus_subset": 0.085674,
+ "full_mnist_test_acc_mean": 0.85556,
+ "subset_study_test_acc_mean": 0.8158,
+ "test_acc_delta_full_minus_subset": 0.03976
+ },
+ "180": {
+ "full_mnist_train_loss_mean": 0.484713,
+ "subset_study_train_loss_mean": 0.402343,
+ "train_loss_delta_full_minus_subset": 0.08237,
+ "full_mnist_test_acc_mean": 0.86288,
+ "subset_study_test_acc_mean": 0.8212,
+ "test_acc_delta_full_minus_subset": 0.04168
+ },
+ "200": {
+ "full_mnist_train_loss_mean": 0.465194,
+ "subset_study_train_loss_mean": 0.38532,
+ "train_loss_delta_full_minus_subset": 0.079874,
+ "full_mnist_test_acc_mean": 0.86852,
+ "subset_study_test_acc_mean": 0.8258,
+ "test_acc_delta_full_minus_subset": 0.04272
+ },
+ "220": {
+ "full_mnist_train_loss_mean": 0.448783,
+ "subset_study_train_loss_mean": 0.371485,
+ "train_loss_delta_full_minus_subset": 0.077298,
+ "full_mnist_test_acc_mean": 0.87386,
+ "subset_study_test_acc_mean": 0.8308,
+ "test_acc_delta_full_minus_subset": 0.04306
+ },
+ "240": {
+ "full_mnist_train_loss_mean": 0.436664,
+ "subset_study_train_loss_mean": 0.359582,
+ "train_loss_delta_full_minus_subset": 0.077082,
+ "full_mnist_test_acc_mean": 0.87698,
+ "subset_study_test_acc_mean": 0.8352,
+ "test_acc_delta_full_minus_subset": 0.04178
+ }
+ }
+ },
+ "summary": {
+ "epochs": [
+ 20,
+ 40,
+ 60,
+ 80,
+ 100,
+ 120,
+ 140,
+ 160,
+ 180,
+ 200,
+ 220,
+ 240
+ ],
+ "checkpoint_stats": {
+ "20": {
+ "train_loss": {
+ "mean": 1.702249,
+ "std": 0.027025,
+ "median": 1.703111,
+ "iqr": 0.011456,
+ "ci95_t": 0.033556
+ },
+ "train_acc": {
+ "mean": 0.445607,
+ "std": 0.021731,
+ "median": 0.433483,
+ "iqr": 0.02585,
+ "ci95_t": 0.026982
+ },
+ "train_mse": {
+ "mean": 0.071485,
+ "std": 0.001656,
+ "median": 0.072119,
+ "iqr": 0.001252,
+ "ci95_t": 0.002056
+ },
+ "test_loss": {
+ "mean": 1.671514,
+ "std": 0.03065,
+ "median": 1.677893,
+ "iqr": 0.022486,
+ "ci95_t": 0.038056
+ },
+ "test_acc": {
+ "mean": 0.45414,
+ "std": 0.025621,
+ "median": 0.4423,
+ "iqr": 0.0205,
+ "ci95_t": 0.031812
+ },
+ "test_mse": {
+ "mean": 0.070722,
+ "std": 0.002133,
+ "median": 0.071395,
+ "iqr": 0.001044,
+ "ci95_t": 0.002648
+ }
+ },
+ "40": {
+ "train_loss": {
+ "mean": 1.224695,
+ "std": 0.037452,
+ "median": 1.234723,
+ "iqr": 0.033686,
+ "ci95_t": 0.046502
+ },
+ "train_acc": {
+ "mean": 0.622557,
+ "std": 0.020205,
+ "median": 0.618267,
+ "iqr": 0.022067,
+ "ci95_t": 0.025087
+ },
+ "train_mse": {
+ "mean": 0.052198,
+ "std": 0.002256,
+ "median": 0.053623,
+ "iqr": 0.002668,
+ "ci95_t": 0.002802
+ },
+ "test_loss": {
+ "mean": 1.179788,
+ "std": 0.055076,
+ "median": 1.19379,
+ "iqr": 0.013931,
+ "ci95_t": 0.068384
+ },
+ "test_acc": {
+ "mean": 0.6336,
+ "std": 0.023919,
+ "median": 0.6273,
+ "iqr": 0.0243,
+ "ci95_t": 0.029699
+ },
+ "test_mse": {
+ "mean": 0.05075,
+ "std": 0.002785,
+ "median": 0.052392,
+ "iqr": 0.003492,
+ "ci95_t": 0.003457
+ }
+ },
+ "60": {
+ "train_loss": {
+ "mean": 0.948636,
+ "std": 0.027972,
+ "median": 0.950673,
+ "iqr": 0.012445,
+ "ci95_t": 0.034731
+ },
+ "train_acc": {
+ "mean": 0.71178,
+ "std": 0.009159,
+ "median": 0.709317,
+ "iqr": 0.005433,
+ "ci95_t": 0.011372
+ },
+ "train_mse": {
+ "mean": 0.040717,
+ "std": 0.001113,
+ "median": 0.040739,
+ "iqr": 0.000527,
+ "ci95_t": 0.001382
+ },
+ "test_loss": {
+ "mean": 0.901776,
+ "std": 0.042139,
+ "median": 0.914831,
+ "iqr": 0.021976,
+ "ci95_t": 0.052321
+ },
+ "test_acc": {
+ "mean": 0.7233,
+ "std": 0.013699,
+ "median": 0.7216,
+ "iqr": 0.0083,
+ "ci95_t": 0.01701
+ },
+ "test_mse": {
+ "mean": 0.039174,
+ "std": 0.001593,
+ "median": 0.039782,
+ "iqr": 0.001018,
+ "ci95_t": 0.001978
+ }
+ },
+ "80": {
+ "train_loss": {
+ "mean": 0.768448,
+ "std": 0.026961,
+ "median": 0.769041,
+ "iqr": 0.037431,
+ "ci95_t": 0.033476
+ },
+ "train_acc": {
+ "mean": 0.76559,
+ "std": 0.011184,
+ "median": 0.7677,
+ "iqr": 0.015283,
+ "ci95_t": 0.013887
+ },
+ "train_mse": {
+ "mean": 0.033494,
+ "std": 0.00155,
+ "median": 0.033258,
+ "iqr": 0.002209,
+ "ci95_t": 0.001924
+ },
+ "test_loss": {
+ "mean": 0.725023,
+ "std": 0.033552,
+ "median": 0.722532,
+ "iqr": 0.034073,
+ "ci95_t": 0.041659
+ },
+ "test_acc": {
+ "mean": 0.77672,
+ "std": 0.015009,
+ "median": 0.7825,
+ "iqr": 0.0161,
+ "ci95_t": 0.018636
+ },
+ "test_mse": {
+ "mean": 0.031924,
+ "std": 0.001761,
+ "median": 0.031514,
+ "iqr": 0.002116,
+ "ci95_t": 0.002186
+ }
+ },
+ "100": {
+ "train_loss": {
+ "mean": 0.65688,
+ "std": 0.020915,
+ "median": 0.660741,
+ "iqr": 0.011426,
+ "ci95_t": 0.025969
+ },
+ "train_acc": {
+ "mean": 0.801067,
+ "std": 0.007077,
+ "median": 0.797783,
+ "iqr": 0.010417,
+ "ci95_t": 0.008787
+ },
+ "train_mse": {
+ "mean": 0.028713,
+ "std": 0.001089,
+ "median": 0.029053,
+ "iqr": 0.001428,
+ "ci95_t": 0.001352
+ },
+ "test_loss": {
+ "mean": 0.615132,
+ "std": 0.02617,
+ "median": 0.621342,
+ "iqr": 0.037245,
+ "ci95_t": 0.032494
+ },
+ "test_acc": {
+ "mean": 0.81266,
+ "std": 0.010774,
+ "median": 0.8092,
+ "iqr": 0.0171,
+ "ci95_t": 0.013377
+ },
+ "test_mse": {
+ "mean": 0.02696,
+ "std": 0.001359,
+ "median": 0.027381,
+ "iqr": 0.002195,
+ "ci95_t": 0.001687
+ }
+ },
+ "120": {
+ "train_loss": {
+ "mean": 0.589822,
+ "std": 0.014141,
+ "median": 0.588559,
+ "iqr": 0.001475,
+ "ci95_t": 0.017558
+ },
+ "train_acc": {
+ "mean": 0.822093,
+ "std": 0.0057,
+ "median": 0.822533,
+ "iqr": 0.005717,
+ "ci95_t": 0.007077
+ },
+ "train_mse": {
+ "mean": 0.025757,
+ "std": 0.000826,
+ "median": 0.025579,
+ "iqr": 0.000792,
+ "ci95_t": 0.001025
+ },
+ "test_loss": {
+ "mean": 0.551133,
+ "std": 0.018616,
+ "median": 0.551455,
+ "iqr": 0.032642,
+ "ci95_t": 0.023115
+ },
+ "test_acc": {
+ "mean": 0.83284,
+ "std": 0.008339,
+ "median": 0.8325,
+ "iqr": 0.0116,
+ "ci95_t": 0.010354
+ },
+ "test_mse": {
+ "mean": 0.024175,
+ "std": 0.001111,
+ "median": 0.024057,
+ "iqr": 0.001382,
+ "ci95_t": 0.00138
+ }
+ },
+ "140": {
+ "train_loss": {
+ "mean": 0.546798,
+ "std": 0.013752,
+ "median": 0.55098,
+ "iqr": 0.01484,
+ "ci95_t": 0.017075
+ },
+ "train_acc": {
+ "mean": 0.835563,
+ "std": 0.003866,
+ "median": 0.836767,
+ "iqr": 0.00585,
+ "ci95_t": 0.004801
+ },
+ "train_mse": {
+ "mean": 0.023943,
+ "std": 0.000571,
+ "median": 0.023784,
+ "iqr": 0.000191,
+ "ci95_t": 0.000709
+ },
+ "test_loss": {
+ "mean": 0.514915,
+ "std": 0.012244,
+ "median": 0.511442,
+ "iqr": 0.008307,
+ "ci95_t": 0.015203
+ },
+ "test_acc": {
+ "mean": 0.84378,
+ "std": 0.005974,
+ "median": 0.8463,
+ "iqr": 0.0088,
+ "ci95_t": 0.007417
+ },
+ "test_mse": {
+ "mean": 0.022561,
+ "std": 0.000752,
+ "median": 0.022098,
+ "iqr": 0.00091,
+ "ci95_t": 0.000934
+ }
+ },
+ "160": {
+ "train_loss": {
+ "mean": 0.511683,
+ "std": 0.013526,
+ "median": 0.512245,
+ "iqr": 0.016255,
+ "ci95_t": 0.016794
+ },
+ "train_acc": {
+ "mean": 0.846747,
+ "std": 0.003612,
+ "median": 0.84645,
+ "iqr": 0.003383,
+ "ci95_t": 0.004485
+ },
+ "train_mse": {
+ "mean": 0.022519,
+ "std": 0.000546,
+ "median": 0.022432,
+ "iqr": 0.000328,
+ "ci95_t": 0.000678
+ },
+ "test_loss": {
+ "mean": 0.482441,
+ "std": 0.012016,
+ "median": 0.482125,
+ "iqr": 0.007918,
+ "ci95_t": 0.014919
+ },
+ "test_acc": {
+ "mean": 0.85556,
+ "std": 0.005556,
+ "median": 0.857,
+ "iqr": 0.0018,
+ "ci95_t": 0.006898
+ },
+ "test_mse": {
+ "mean": 0.021226,
+ "std": 0.000611,
+ "median": 0.02103,
+ "iqr": 0.000343,
+ "ci95_t": 0.000759
+ }
+ },
+ "180": {
+ "train_loss": {
+ "mean": 0.484713,
+ "std": 0.010051,
+ "median": 0.48282,
+ "iqr": 0.012583,
+ "ci95_t": 0.012479
+ },
+ "train_acc": {
+ "mean": 0.85437,
+ "std": 0.002991,
+ "median": 0.8547,
+ "iqr": 0.002217,
+ "ci95_t": 0.003713
+ },
+ "train_mse": {
+ "mean": 0.021385,
+ "std": 0.000444,
+ "median": 0.021225,
+ "iqr": 0.000247,
+ "ci95_t": 0.000551
+ },
+ "test_loss": {
+ "mean": 0.456956,
+ "std": 0.010149,
+ "median": 0.454655,
+ "iqr": 0.005472,
+ "ci95_t": 0.012601
+ },
+ "test_acc": {
+ "mean": 0.86288,
+ "std": 0.005108,
+ "median": 0.8646,
+ "iqr": 0.0036,
+ "ci95_t": 0.006342
+ },
+ "test_mse": {
+ "mean": 0.020134,
+ "std": 0.000608,
+ "median": 0.01998,
+ "iqr": 0.000199,
+ "ci95_t": 0.000754
+ }
+ },
+ "200": {
+ "train_loss": {
+ "mean": 0.465194,
+ "std": 0.010498,
+ "median": 0.462939,
+ "iqr": 0.008508,
+ "ci95_t": 0.013034
+ },
+ "train_acc": {
+ "mean": 0.861527,
+ "std": 0.003159,
+ "median": 0.8621,
+ "iqr": 0.002083,
+ "ci95_t": 0.003922
+ },
+ "train_mse": {
+ "mean": 0.020487,
+ "std": 0.000433,
+ "median": 0.020342,
+ "iqr": 0.000304,
+ "ci95_t": 0.000538
+ },
+ "test_loss": {
+ "mean": 0.438875,
+ "std": 0.008499,
+ "median": 0.436988,
+ "iqr": 0.008313,
+ "ci95_t": 0.010552
+ },
+ "test_acc": {
+ "mean": 0.86852,
+ "std": 0.00318,
+ "median": 0.8695,
+ "iqr": 0.0023,
+ "ci95_t": 0.003948
+ },
+ "test_mse": {
+ "mean": 0.019328,
+ "std": 0.000455,
+ "median": 0.019186,
+ "iqr": 0.000367,
+ "ci95_t": 0.000565
+ }
+ },
+ "220": {
+ "train_loss": {
+ "mean": 0.448783,
+ "std": 0.009652,
+ "median": 0.44595,
+ "iqr": 0.009673,
+ "ci95_t": 0.011984
+ },
+ "train_acc": {
+ "mean": 0.866403,
+ "std": 0.003182,
+ "median": 0.866417,
+ "iqr": 0.002467,
+ "ci95_t": 0.003951
+ },
+ "train_mse": {
+ "mean": 0.019789,
+ "std": 0.000417,
+ "median": 0.019721,
+ "iqr": 0.000391,
+ "ci95_t": 0.000518
+ },
+ "test_loss": {
+ "mean": 0.423267,
+ "std": 0.007379,
+ "median": 0.421121,
+ "iqr": 0.003368,
+ "ci95_t": 0.009163
+ },
+ "test_acc": {
+ "mean": 0.87386,
+ "std": 0.00329,
+ "median": 0.8754,
+ "iqr": 0.0027,
+ "ci95_t": 0.004085
+ },
+ "test_mse": {
+ "mean": 0.018639,
+ "std": 0.000401,
+ "median": 0.018519,
+ "iqr": 5.8e-05,
+ "ci95_t": 0.000498
+ }
+ },
+ "240": {
+ "train_loss": {
+ "mean": 0.436664,
+ "std": 0.008101,
+ "median": 0.435042,
+ "iqr": 0.007916,
+ "ci95_t": 0.010059
+ },
+ "train_acc": {
+ "mean": 0.87058,
+ "std": 0.00256,
+ "median": 0.871567,
+ "iqr": 0.00255,
+ "ci95_t": 0.003179
+ },
+ "train_mse": {
+ "mean": 0.019262,
+ "std": 0.00035,
+ "median": 0.019168,
+ "iqr": 0.000271,
+ "ci95_t": 0.000435
+ },
+ "test_loss": {
+ "mean": 0.412078,
+ "std": 0.006848,
+ "median": 0.410605,
+ "iqr": 0.001626,
+ "ci95_t": 0.008503
+ },
+ "test_acc": {
+ "mean": 0.87698,
+ "std": 0.00356,
+ "median": 0.878,
+ "iqr": 0.0049,
+ "ci95_t": 0.00442
+ },
+ "test_mse": {
+ "mean": 0.018165,
+ "std": 0.000373,
+ "median": 0.0181,
+ "iqr": 0.000145,
+ "ci95_t": 0.000463
+ }
+ }
+ },
+ "paired_deltas": {
+ "80_to_240": {
+ "train_loss_rel_reduction": {
+ "mean": 0.43121,
+ "std": 0.022009,
+ "median": 0.42456,
+ "iqr": 0.012936,
+ "ci95_t": 0.027327
+ },
+ "test_acc_delta": {
+ "mean": 0.10026,
+ "std": 0.015267,
+ "median": 0.0967,
+ "iqr": 0.0122,
+ "ci95_t": 0.018956
+ }
+ },
+ "200_to_240": {
+ "train_loss_rel_reduction": {
+ "mean": 0.061255,
+ "std": 0.005532,
+ "median": 0.064274,
+ "iqr": 0.004111,
+ "ci95_t": 0.006869
+ },
+ "test_acc_delta": {
+ "mean": 0.00846,
+ "std": 0.003068,
+ "median": 0.0083,
+ "iqr": 0.0043,
+ "ci95_t": 0.003809
+ },
+ "test_acc_abs_change": {
+ "mean": 0.00846,
+ "std": 0.003068,
+ "median": 0.0083,
+ "iqr": 0.0043,
+ "ci95_t": 0.003809
+ }
+ }
+ },
+ "paired_endpoint_deltas_by_seed": [
+ {
+ "seed": 71,
+ "train_loss_relative_reduction_80_to_240": 0.4087744063945915,
+ "test_accuracy_delta_80_to_240": 0.08350002765655518,
+ "train_loss_relative_reduction_200_to_240": 0.06437137468530654,
+ "test_accuracy_delta_200_to_240": 0.006099998950958252
+ },
+ {
+ "seed": 72,
+ "train_loss_relative_reduction_80_to_240": 0.4343062808203916,
+ "test_accuracy_delta_80_to_240": 0.09249997138977051,
+ "train_loss_relative_reduction_200_to_240": 0.060260224804917016,
+ "test_accuracy_delta_200_to_240": 0.004999995231628418
+ },
+ {
+ "seed": 73,
+ "train_loss_relative_reduction_80_to_240": 0.4245599802850055,
+ "test_accuracy_delta_80_to_240": 0.10470002889633179,
+ "train_loss_relative_reduction_200_to_240": 0.06537021359043371,
+ "test_accuracy_delta_200_to_240": 0.00830000638961792
+ },
+ {
+ "seed": 74,
+ "train_loss_relative_reduction_80_to_240": 0.4213704110098672,
+ "test_accuracy_delta_80_to_240": 0.09669995307922363,
+ "train_loss_relative_reduction_200_to_240": 0.06427437781113524,
+ "test_accuracy_delta_200_to_240": 0.010399997234344482
+ },
+ {
+ "seed": 75,
+ "train_loss_relative_reduction_80_to_240": 0.46703678712051505,
+ "test_accuracy_delta_80_to_240": 0.12390005588531494,
+ "train_loss_relative_reduction_200_to_240": 0.051999334249014935,
+ "test_accuracy_delta_200_to_240": 0.01250004768371582
+ }
+ ]
+ },
+ "runs": [
+ {
+ "seed": 71,
+ "model_fingerprint": "0777bd52fd76272d",
+ "fit_time_sec": 33.649,
+ "improvement_count": 236,
+ "last_improvement_epoch": 240,
+ "checkpoints": [
+ {
+ "epoch": 20,
+ "train_loss": 1.6637481451034546,
+ "train_acc": 0.4778333306312561,
+ "train_mse": 0.06879015266895294,
+ "test_loss": 1.6244964599609375,
+ "test_acc": 0.4961000084877014,
+ "test_mse": 0.0671548843383789
+ },
+ {
+ "epoch": 40,
+ "train_loss": 1.165610432624817,
+ "train_acc": 0.6545166373252869,
+ "train_mse": 0.04875154793262482,
+ "test_loss": 1.0854827165603638,
+ "test_acc": 0.6718000173568726,
+ "test_mse": 0.046549420803785324
+ },
+ {
+ "epoch": 60,
+ "train_loss": 0.905483067035675,
+ "train_acc": 0.7269166707992554,
+ "train_mse": 0.0389271154999733,
+ "test_loss": 0.8291375041007996,
+ "test_acc": 0.7445999979972839,
+ "test_mse": 0.036550913006067276
+ },
+ {
+ "epoch": 80,
+ "train_loss": 0.7415720224380493,
+ "train_acc": 0.7783499956130981,
+ "train_mse": 0.03182263299822807,
+ "test_loss": 0.6753337979316711,
+ "test_acc": 0.7944999933242798,
+ "test_mse": 0.029618915170431137
+ },
+ {
+ "epoch": 100,
+ "train_loss": 0.6563442945480347,
+ "train_acc": 0.8064000010490417,
+ "train_mse": 0.02799912355840206,
+ "test_loss": 0.5993074178695679,
+ "test_acc": 0.8216999769210815,
+ "test_mse": 0.025761328637599945
+ },
+ {
+ "epoch": 120,
+ "train_loss": 0.588559091091156,
+ "train_acc": 0.8279500007629395,
+ "train_mse": 0.025105126202106476,
+ "test_loss": 0.5335480570793152,
+ "test_acc": 0.8414999842643738,
+ "test_mse": 0.022965701296925545
+ },
+ {
+ "epoch": 140,
+ "train_loss": 0.5534469485282898,
+ "train_acc": 0.8387500047683716,
+ "train_mse": 0.023768901824951172,
+ "test_loss": 0.5105180144309998,
+ "test_acc": 0.8489999771118164,
+ "test_mse": 0.022098202258348465
+ },
+ {
+ "epoch": 160,
+ "train_loss": 0.5169084668159485,
+ "train_acc": 0.8464000225067139,
+ "train_mse": 0.022431854158639908,
+ "test_loss": 0.4750884771347046,
+ "test_acc": 0.8555999994277954,
+ "test_mse": 0.02082662656903267
+ },
+ {
+ "epoch": 180,
+ "train_loss": 0.48863890767097473,
+ "train_acc": 0.8547000288963318,
+ "train_mse": 0.021347153931856155,
+ "test_loss": 0.4477296769618988,
+ "test_acc": 0.8686000108718872,
+ "test_mse": 0.01953563280403614
+ },
+ {
+ "epoch": 200,
+ "train_loss": 0.4686008393764496,
+ "train_acc": 0.8610333204269409,
+ "train_mse": 0.020526422187685966,
+ "test_loss": 0.43183833360671997,
+ "test_acc": 0.8719000220298767,
+ "test_mse": 0.018971838057041168
+ },
+ {
+ "epoch": 220,
+ "train_loss": 0.45222264528274536,
+ "train_acc": 0.8653833270072937,
+ "train_mse": 0.0198610108345747,
+ "test_loss": 0.4211212396621704,
+ "test_acc": 0.8756999969482422,
+ "test_mse": 0.01851881667971611
+ },
+ {
+ "epoch": 240,
+ "train_loss": 0.438436359167099,
+ "train_acc": 0.8698999881744385,
+ "train_mse": 0.019294776022434235,
+ "test_loss": 0.41157108545303345,
+ "test_acc": 0.878000020980835,
+ "test_mse": 0.018099937587976456
+ }
+ ],
+ "completed": true,
+ "error": null,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "epoch_history": [
+ {
+ "epoch": 1,
+ "loss": 2.4799604415893555,
+ "accuracy": 0.09071666747331619,
+ "mse": 0.09381373226642609
+ },
+ {
+ "epoch": 2,
+ "loss": 2.4182791709899902,
+ "accuracy": 0.13456666469573975,
+ "mse": 0.09253817051649094
+ },
+ {
+ "epoch": 3,
+ "loss": 2.3741824626922607,
+ "accuracy": 0.16071666777133942,
+ "mse": 0.09159322828054428
+ },
+ {
+ "epoch": 4,
+ "loss": 2.3180394172668457,
+ "accuracy": 0.17541666328907013,
+ "mse": 0.0904107466340065
+ },
+ {
+ "epoch": 5,
+ "loss": 2.2673306465148926,
+ "accuracy": 0.21481665968894958,
+ "mse": 0.08884409815073013
+ },
+ {
+ "epoch": 6,
+ "loss": 2.2301437854766846,
+ "accuracy": 0.22741666436195374,
+ "mse": 0.0880921483039856
+ },
+ {
+ "epoch": 7,
+ "loss": 2.225552797317505,
+ "accuracy": 0.24686667323112488,
+ "mse": 0.08829189091920853
+ },
+ {
+ "epoch": 8,
+ "loss": 2.1702444553375244,
+ "accuracy": 0.24406667053699493,
+ "mse": 0.08694970607757568
+ },
+ {
+ "epoch": 9,
+ "loss": 2.1111176013946533,
+ "accuracy": 0.26758334040641785,
+ "mse": 0.08507717400789261
+ },
+ {
+ "epoch": 10,
+ "loss": 2.0960006713867188,
+ "accuracy": 0.267549991607666,
+ "mse": 0.08456980437040329
+ },
+ {
+ "epoch": 11,
+ "loss": 2.0432260036468506,
+ "accuracy": 0.28868332505226135,
+ "mse": 0.08316299319267273
+ },
+ {
+ "epoch": 12,
+ "loss": 2.0000269412994385,
+ "accuracy": 0.2998666763305664,
+ "mse": 0.0821836069226265
+ },
+ {
+ "epoch": 13,
+ "loss": 1.9665766954421997,
+ "accuracy": 0.3221166729927063,
+ "mse": 0.08079516887664795
+ },
+ {
+ "epoch": 14,
+ "loss": 1.9129518270492554,
+ "accuracy": 0.3467499911785126,
+ "mse": 0.07892955839633942
+ },
+ {
+ "epoch": 15,
+ "loss": 1.8766807317733765,
+ "accuracy": 0.3644833266735077,
+ "mse": 0.0775030180811882
+ },
+ {
+ "epoch": 16,
+ "loss": 1.8075673580169678,
+ "accuracy": 0.4006499946117401,
+ "mse": 0.07487130165100098
+ },
+ {
+ "epoch": 17,
+ "loss": 1.7618496417999268,
+ "accuracy": 0.4309833347797394,
+ "mse": 0.07268904149532318
+ },
+ {
+ "epoch": 18,
+ "loss": 1.72720205783844,
+ "accuracy": 0.4496000111103058,
+ "mse": 0.07150349020957947
+ },
+ {
+ "epoch": 19,
+ "loss": 1.6890857219696045,
+ "accuracy": 0.46799999475479126,
+ "mse": 0.06981472671031952
+ },
+ {
+ "epoch": 20,
+ "loss": 1.6637481451034546,
+ "accuracy": 0.4778333306312561,
+ "mse": 0.06879015266895294
+ },
+ {
+ "epoch": 21,
+ "loss": 1.6207212209701538,
+ "accuracy": 0.5000166893005371,
+ "mse": 0.06667102873325348
+ },
+ {
+ "epoch": 22,
+ "loss": 1.590189814567566,
+ "accuracy": 0.5103999972343445,
+ "mse": 0.06591764092445374
+ },
+ {
+ "epoch": 23,
+ "loss": 1.55740487575531,
+ "accuracy": 0.5206166505813599,
+ "mse": 0.06438755989074707
+ },
+ {
+ "epoch": 24,
+ "loss": 1.5221445560455322,
+ "accuracy": 0.5372666716575623,
+ "mse": 0.06303995102643967
+ },
+ {
+ "epoch": 25,
+ "loss": 1.4974141120910645,
+ "accuracy": 0.5442000031471252,
+ "mse": 0.0621832013130188
+ },
+ {
+ "epoch": 26,
+ "loss": 1.464286208152771,
+ "accuracy": 0.5581333041191101,
+ "mse": 0.06063959002494812
+ },
+ {
+ "epoch": 27,
+ "loss": 1.4368863105773926,
+ "accuracy": 0.5668166875839233,
+ "mse": 0.05941622331738472
+ },
+ {
+ "epoch": 28,
+ "loss": 1.4122096300125122,
+ "accuracy": 0.5736666917800903,
+ "mse": 0.058365847915410995
+ },
+ {
+ "epoch": 29,
+ "loss": 1.393170952796936,
+ "accuracy": 0.5837833285331726,
+ "mse": 0.0574859194457531
+ },
+ {
+ "epoch": 30,
+ "loss": 1.3689682483673096,
+ "accuracy": 0.5904333591461182,
+ "mse": 0.05655674636363983
+ },
+ {
+ "epoch": 31,
+ "loss": 1.3444064855575562,
+ "accuracy": 0.6022499799728394,
+ "mse": 0.05532548949122429
+ },
+ {
+ "epoch": 32,
+ "loss": 1.3268077373504639,
+ "accuracy": 0.6081333160400391,
+ "mse": 0.05478164181113243
+ },
+ {
+ "epoch": 33,
+ "loss": 1.3068965673446655,
+ "accuracy": 0.6131333112716675,
+ "mse": 0.05422866716980934
+ },
+ {
+ "epoch": 34,
+ "loss": 1.2865885496139526,
+ "accuracy": 0.6209333539009094,
+ "mse": 0.05327463150024414
+ },
+ {
+ "epoch": 35,
+ "loss": 1.2549551725387573,
+ "accuracy": 0.630383312702179,
+ "mse": 0.05206596851348877
+ },
+ {
+ "epoch": 36,
+ "loss": 1.237845778465271,
+ "accuracy": 0.6337000131607056,
+ "mse": 0.05165576562285423
+ },
+ {
+ "epoch": 37,
+ "loss": 1.2130557298660278,
+ "accuracy": 0.6421499848365784,
+ "mse": 0.05059630796313286
+ },
+ {
+ "epoch": 38,
+ "loss": 1.1939085721969604,
+ "accuracy": 0.6466666460037231,
+ "mse": 0.05000072345137596
+ },
+ {
+ "epoch": 39,
+ "loss": 1.1764185428619385,
+ "accuracy": 0.650433361530304,
+ "mse": 0.04911484196782112
+ },
+ {
+ "epoch": 40,
+ "loss": 1.165610432624817,
+ "accuracy": 0.6545166373252869,
+ "mse": 0.04875154793262482
+ },
+ {
+ "epoch": 41,
+ "loss": 1.1505037546157837,
+ "accuracy": 0.6572666764259338,
+ "mse": 0.0482388399541378
+ },
+ {
+ "epoch": 42,
+ "loss": 1.1366956233978271,
+ "accuracy": 0.6593999862670898,
+ "mse": 0.04773976653814316
+ },
+ {
+ "epoch": 43,
+ "loss": 1.1173856258392334,
+ "accuracy": 0.6641166806221008,
+ "mse": 0.04712272807955742
+ },
+ {
+ "epoch": 44,
+ "loss": 1.108084797859192,
+ "accuracy": 0.6659666895866394,
+ "mse": 0.046808212995529175
+ },
+ {
+ "epoch": 45,
+ "loss": 1.089038372039795,
+ "accuracy": 0.6699333190917969,
+ "mse": 0.046211495995521545
+ },
+ {
+ "epoch": 46,
+ "loss": 1.0861262083053589,
+ "accuracy": 0.6710500121116638,
+ "mse": 0.0460859052836895
+ },
+ {
+ "epoch": 47,
+ "loss": 1.0675417184829712,
+ "accuracy": 0.6775833368301392,
+ "mse": 0.045410964637994766
+ },
+ {
+ "epoch": 48,
+ "loss": 1.0614193677902222,
+ "accuracy": 0.6785333156585693,
+ "mse": 0.0452471598982811
+ },
+ {
+ "epoch": 49,
+ "loss": 1.0484302043914795,
+ "accuracy": 0.6813666820526123,
+ "mse": 0.04495740309357643
+ },
+ {
+ "epoch": 50,
+ "loss": 1.0333746671676636,
+ "accuracy": 0.6869000196456909,
+ "mse": 0.04425930604338646
+ },
+ {
+ "epoch": 51,
+ "loss": 1.0231231451034546,
+ "accuracy": 0.6888166666030884,
+ "mse": 0.04393915459513664
+ },
+ {
+ "epoch": 52,
+ "loss": 1.0133792161941528,
+ "accuracy": 0.6938666701316833,
+ "mse": 0.04353751987218857
+ },
+ {
+ "epoch": 53,
+ "loss": 0.9903067946434021,
+ "accuracy": 0.6984999775886536,
+ "mse": 0.04265276715159416
+ },
+ {
+ "epoch": 54,
+ "loss": 0.980160653591156,
+ "accuracy": 0.7018333077430725,
+ "mse": 0.04217556118965149
+ },
+ {
+ "epoch": 55,
+ "loss": 0.9651464223861694,
+ "accuracy": 0.7055833339691162,
+ "mse": 0.04165913537144661
+ },
+ {
+ "epoch": 56,
+ "loss": 0.9534841179847717,
+ "accuracy": 0.7092166543006897,
+ "mse": 0.04123298078775406
+ },
+ {
+ "epoch": 57,
+ "loss": 0.9370167851448059,
+ "accuracy": 0.7156000137329102,
+ "mse": 0.04052000865340233
+ },
+ {
+ "epoch": 58,
+ "loss": 0.9272488355636597,
+ "accuracy": 0.7204166650772095,
+ "mse": 0.03992411121726036
+ },
+ {
+ "epoch": 59,
+ "loss": 0.9221512079238892,
+ "accuracy": 0.7226499915122986,
+ "mse": 0.03965400531888008
+ },
+ {
+ "epoch": 60,
+ "loss": 0.905483067035675,
+ "accuracy": 0.7269166707992554,
+ "mse": 0.0389271154999733
+ },
+ {
+ "epoch": 61,
+ "loss": 0.8937400579452515,
+ "accuracy": 0.7333333492279053,
+ "mse": 0.03820435702800751
+ },
+ {
+ "epoch": 62,
+ "loss": 0.8838953375816345,
+ "accuracy": 0.7381333112716675,
+ "mse": 0.037672508507966995
+ },
+ {
+ "epoch": 63,
+ "loss": 0.8726754188537598,
+ "accuracy": 0.741100013256073,
+ "mse": 0.037254415452480316
+ },
+ {
+ "epoch": 64,
+ "loss": 0.8619146943092346,
+ "accuracy": 0.7445666790008545,
+ "mse": 0.03672591596841812
+ },
+ {
+ "epoch": 65,
+ "loss": 0.8540928363800049,
+ "accuracy": 0.746916651725769,
+ "mse": 0.0364634171128273
+ },
+ {
+ "epoch": 66,
+ "loss": 0.8436437249183655,
+ "accuracy": 0.7493166923522949,
+ "mse": 0.0361650250852108
+ },
+ {
+ "epoch": 67,
+ "loss": 0.8371605277061462,
+ "accuracy": 0.7517333626747131,
+ "mse": 0.03563384339213371
+ },
+ {
+ "epoch": 68,
+ "loss": 0.8303015828132629,
+ "accuracy": 0.7523999810218811,
+ "mse": 0.035406604409217834
+ },
+ {
+ "epoch": 69,
+ "loss": 0.8204352855682373,
+ "accuracy": 0.7547000050544739,
+ "mse": 0.0350043959915638
+ },
+ {
+ "epoch": 70,
+ "loss": 0.8162333965301514,
+ "accuracy": 0.7568333148956299,
+ "mse": 0.03477025404572487
+ },
+ {
+ "epoch": 71,
+ "loss": 0.8075038194656372,
+ "accuracy": 0.7595333456993103,
+ "mse": 0.03433854132890701
+ },
+ {
+ "epoch": 72,
+ "loss": 0.8001278638839722,
+ "accuracy": 0.7609333395957947,
+ "mse": 0.034072741866111755
+ },
+ {
+ "epoch": 73,
+ "loss": 0.791833221912384,
+ "accuracy": 0.765500009059906,
+ "mse": 0.03370143845677376
+ },
+ {
+ "epoch": 74,
+ "loss": 0.7860501408576965,
+ "accuracy": 0.7650666832923889,
+ "mse": 0.03361719101667404
+ },
+ {
+ "epoch": 75,
+ "loss": 0.7785402536392212,
+ "accuracy": 0.7688000202178955,
+ "mse": 0.03302460163831711
+ },
+ {
+ "epoch": 76,
+ "loss": 0.7677525877952576,
+ "accuracy": 0.7704833149909973,
+ "mse": 0.03283839672803879
+ },
+ {
+ "epoch": 77,
+ "loss": 0.7588521242141724,
+ "accuracy": 0.7742000222206116,
+ "mse": 0.032444242388010025
+ },
+ {
+ "epoch": 78,
+ "loss": 0.7562710642814636,
+ "accuracy": 0.7744666934013367,
+ "mse": 0.032258041203022
+ },
+ {
+ "epoch": 79,
+ "loss": 0.7473954558372498,
+ "accuracy": 0.777400016784668,
+ "mse": 0.03198157623410225
+ },
+ {
+ "epoch": 80,
+ "loss": 0.7415720224380493,
+ "accuracy": 0.7783499956130981,
+ "mse": 0.03182263299822807
+ },
+ {
+ "epoch": 81,
+ "loss": 0.7365007996559143,
+ "accuracy": 0.7795000076293945,
+ "mse": 0.03163003921508789
+ },
+ {
+ "epoch": 82,
+ "loss": 0.7328322529792786,
+ "accuracy": 0.7797999978065491,
+ "mse": 0.0315045528113842
+ },
+ {
+ "epoch": 83,
+ "loss": 0.7246185541152954,
+ "accuracy": 0.782716691493988,
+ "mse": 0.03118823654949665
+ },
+ {
+ "epoch": 84,
+ "loss": 0.7225574254989624,
+ "accuracy": 0.7845166921615601,
+ "mse": 0.03108087182044983
+ },
+ {
+ "epoch": 85,
+ "loss": 0.718132734298706,
+ "accuracy": 0.7856500148773193,
+ "mse": 0.030934056267142296
+ },
+ {
+ "epoch": 86,
+ "loss": 0.7165713906288147,
+ "accuracy": 0.7851166725158691,
+ "mse": 0.03090844675898552
+ },
+ {
+ "epoch": 87,
+ "loss": 0.7114774584770203,
+ "accuracy": 0.788100004196167,
+ "mse": 0.03062072955071926
+ },
+ {
+ "epoch": 88,
+ "loss": 0.7077392339706421,
+ "accuracy": 0.7884500026702881,
+ "mse": 0.030440350994467735
+ },
+ {
+ "epoch": 89,
+ "loss": 0.7034558653831482,
+ "accuracy": 0.7881666421890259,
+ "mse": 0.030375882983207703
+ },
+ {
+ "epoch": 90,
+ "loss": 0.6980968713760376,
+ "accuracy": 0.7905666828155518,
+ "mse": 0.03006909415125847
+ },
+ {
+ "epoch": 91,
+ "loss": 0.6953916549682617,
+ "accuracy": 0.7919166684150696,
+ "mse": 0.029957473278045654
+ },
+ {
+ "epoch": 92,
+ "loss": 0.6889597177505493,
+ "accuracy": 0.7941166758537292,
+ "mse": 0.02968638949096203
+ },
+ {
+ "epoch": 93,
+ "loss": 0.6824026703834534,
+ "accuracy": 0.7968833446502686,
+ "mse": 0.029310937970876694
+ },
+ {
+ "epoch": 94,
+ "loss": 0.6806131601333618,
+ "accuracy": 0.7962666749954224,
+ "mse": 0.029194438830018044
+ },
+ {
+ "epoch": 95,
+ "loss": 0.674738883972168,
+ "accuracy": 0.7992500066757202,
+ "mse": 0.028942884877324104
+ },
+ {
+ "epoch": 96,
+ "loss": 0.6734980940818787,
+ "accuracy": 0.7999666929244995,
+ "mse": 0.02879643626511097
+ },
+ {
+ "epoch": 97,
+ "loss": 0.6693940162658691,
+ "accuracy": 0.8001833558082581,
+ "mse": 0.028629377484321594
+ },
+ {
+ "epoch": 98,
+ "loss": 0.6661651730537415,
+ "accuracy": 0.8019000291824341,
+ "mse": 0.028522493317723274
+ },
+ {
+ "epoch": 99,
+ "loss": 0.6611137390136719,
+ "accuracy": 0.8032000064849854,
+ "mse": 0.028347304090857506
+ },
+ {
+ "epoch": 100,
+ "loss": 0.6563442945480347,
+ "accuracy": 0.8064000010490417,
+ "mse": 0.02799912355840206
+ },
+ {
+ "epoch": 101,
+ "loss": 0.6536142826080322,
+ "accuracy": 0.8058666586875916,
+ "mse": 0.028034934774041176
+ },
+ {
+ "epoch": 102,
+ "loss": 0.6465148329734802,
+ "accuracy": 0.808983325958252,
+ "mse": 0.027616014704108238
+ },
+ {
+ "epoch": 103,
+ "loss": 0.644207239151001,
+ "accuracy": 0.8100000023841858,
+ "mse": 0.02760196290910244
+ },
+ {
+ "epoch": 104,
+ "loss": 0.6392351388931274,
+ "accuracy": 0.8116666674613953,
+ "mse": 0.027295541018247604
+ },
+ {
+ "epoch": 105,
+ "loss": 0.6368376016616821,
+ "accuracy": 0.8121166825294495,
+ "mse": 0.027203453704714775
+ },
+ {
+ "epoch": 106,
+ "loss": 0.6340487003326416,
+ "accuracy": 0.8123499751091003,
+ "mse": 0.027078676968812943
+ },
+ {
+ "epoch": 107,
+ "loss": 0.6286861896514893,
+ "accuracy": 0.814050018787384,
+ "mse": 0.026805326342582703
+ },
+ {
+ "epoch": 108,
+ "loss": 0.6248790621757507,
+ "accuracy": 0.8150666952133179,
+ "mse": 0.02668251283466816
+ },
+ {
+ "epoch": 109,
+ "loss": 0.623947024345398,
+ "accuracy": 0.8150333166122437,
+ "mse": 0.026687057688832283
+ },
+ {
+ "epoch": 110,
+ "loss": 0.6215196847915649,
+ "accuracy": 0.8169999718666077,
+ "mse": 0.026516249403357506
+ },
+ {
+ "epoch": 111,
+ "loss": 0.6168358325958252,
+ "accuracy": 0.8178166747093201,
+ "mse": 0.026306286454200745
+ },
+ {
+ "epoch": 112,
+ "loss": 0.6153803467750549,
+ "accuracy": 0.817883312702179,
+ "mse": 0.02625950612127781
+ },
+ {
+ "epoch": 113,
+ "loss": 0.6116726398468018,
+ "accuracy": 0.8193333148956299,
+ "mse": 0.026154648512601852
+ },
+ {
+ "epoch": 114,
+ "loss": 0.6097941994667053,
+ "accuracy": 0.820900022983551,
+ "mse": 0.025972960516810417
+ },
+ {
+ "epoch": 115,
+ "loss": 0.6073502898216248,
+ "accuracy": 0.8210999965667725,
+ "mse": 0.025886625051498413
+ },
+ {
+ "epoch": 116,
+ "loss": 0.6033998131752014,
+ "accuracy": 0.8228999972343445,
+ "mse": 0.0257033072412014
+ },
+ {
+ "epoch": 117,
+ "loss": 0.598659098148346,
+ "accuracy": 0.8239333629608154,
+ "mse": 0.025499867275357246
+ },
+ {
+ "epoch": 118,
+ "loss": 0.5953508019447327,
+ "accuracy": 0.8257666826248169,
+ "mse": 0.02535123936831951
+ },
+ {
+ "epoch": 119,
+ "loss": 0.5913713574409485,
+ "accuracy": 0.8256499767303467,
+ "mse": 0.025267748162150383
+ },
+ {
+ "epoch": 120,
+ "loss": 0.588559091091156,
+ "accuracy": 0.8279500007629395,
+ "mse": 0.025105126202106476
+ },
+ {
+ "epoch": 121,
+ "loss": 0.587568998336792,
+ "accuracy": 0.8275666832923889,
+ "mse": 0.025040097534656525
+ },
+ {
+ "epoch": 122,
+ "loss": 0.5854325294494629,
+ "accuracy": 0.82833331823349,
+ "mse": 0.024959195405244827
+ },
+ {
+ "epoch": 123,
+ "loss": 0.5826907753944397,
+ "accuracy": 0.8291000127792358,
+ "mse": 0.024875029921531677
+ },
+ {
+ "epoch": 124,
+ "loss": 0.5804960131645203,
+ "accuracy": 0.8298333287239075,
+ "mse": 0.024787012487649918
+ },
+ {
+ "epoch": 125,
+ "loss": 0.5777565240859985,
+ "accuracy": 0.8305333256721497,
+ "mse": 0.024701936170458794
+ },
+ {
+ "epoch": 126,
+ "loss": 0.5756357908248901,
+ "accuracy": 0.8310333490371704,
+ "mse": 0.02466517500579357
+ },
+ {
+ "epoch": 127,
+ "loss": 0.5747551918029785,
+ "accuracy": 0.8322166800498962,
+ "mse": 0.02461945079267025
+ },
+ {
+ "epoch": 128,
+ "loss": 0.5731144547462463,
+ "accuracy": 0.8315666913986206,
+ "mse": 0.02458832412958145
+ },
+ {
+ "epoch": 129,
+ "loss": 0.5704113245010376,
+ "accuracy": 0.8328333497047424,
+ "mse": 0.024494946002960205
+ },
+ {
+ "epoch": 130,
+ "loss": 0.5689629316329956,
+ "accuracy": 0.8332333564758301,
+ "mse": 0.024416770786046982
+ },
+ {
+ "epoch": 131,
+ "loss": 0.5673589706420898,
+ "accuracy": 0.8339666724205017,
+ "mse": 0.024289147928357124
+ },
+ {
+ "epoch": 132,
+ "loss": 0.5663169026374817,
+ "accuracy": 0.8342333436012268,
+ "mse": 0.02431466430425644
+ },
+ {
+ "epoch": 133,
+ "loss": 0.565825343132019,
+ "accuracy": 0.8330166935920715,
+ "mse": 0.024390729144215584
+ },
+ {
+ "epoch": 134,
+ "loss": 0.5622870922088623,
+ "accuracy": 0.8347166776657104,
+ "mse": 0.024161864072084427
+ },
+ {
+ "epoch": 135,
+ "loss": 0.5616499781608582,
+ "accuracy": 0.8359333276748657,
+ "mse": 0.024116670712828636
+ },
+ {
+ "epoch": 136,
+ "loss": 0.5593075752258301,
+ "accuracy": 0.8363166451454163,
+ "mse": 0.024042382836341858
+ },
+ {
+ "epoch": 137,
+ "loss": 0.5573229193687439,
+ "accuracy": 0.8375166654586792,
+ "mse": 0.023899702355265617
+ },
+ {
+ "epoch": 138,
+ "loss": 0.5561546683311462,
+ "accuracy": 0.8378499746322632,
+ "mse": 0.02387295290827751
+ },
+ {
+ "epoch": 139,
+ "loss": 0.5547305941581726,
+ "accuracy": 0.838533341884613,
+ "mse": 0.023795565590262413
+ },
+ {
+ "epoch": 140,
+ "loss": 0.5534469485282898,
+ "accuracy": 0.8387500047683716,
+ "mse": 0.023768901824951172
+ },
+ {
+ "epoch": 141,
+ "loss": 0.5493727922439575,
+ "accuracy": 0.8396333456039429,
+ "mse": 0.02359243854880333
+ },
+ {
+ "epoch": 142,
+ "loss": 0.5490682721138,
+ "accuracy": 0.8387666940689087,
+ "mse": 0.023622410371899605
+ },
+ {
+ "epoch": 143,
+ "loss": 0.546362042427063,
+ "accuracy": 0.8399166464805603,
+ "mse": 0.023494208231568336
+ },
+ {
+ "epoch": 144,
+ "loss": 0.5454352498054504,
+ "accuracy": 0.8408666849136353,
+ "mse": 0.023461738601326942
+ },
+ {
+ "epoch": 145,
+ "loss": 0.5432909727096558,
+ "accuracy": 0.8400166630744934,
+ "mse": 0.023404313251376152
+ },
+ {
+ "epoch": 146,
+ "loss": 0.542500913143158,
+ "accuracy": 0.8406833410263062,
+ "mse": 0.023365939036011696
+ },
+ {
+ "epoch": 147,
+ "loss": 0.5411774516105652,
+ "accuracy": 0.8410500288009644,
+ "mse": 0.023328054696321487
+ },
+ {
+ "epoch": 148,
+ "loss": 0.5383115410804749,
+ "accuracy": 0.8420666456222534,
+ "mse": 0.02316419407725334
+ },
+ {
+ "epoch": 149,
+ "loss": 0.5350737571716309,
+ "accuracy": 0.8430833220481873,
+ "mse": 0.023031627759337425
+ },
+ {
+ "epoch": 150,
+ "loss": 0.5327555537223816,
+ "accuracy": 0.8434833288192749,
+ "mse": 0.02300850674510002
+ },
+ {
+ "epoch": 151,
+ "loss": 0.5319739580154419,
+ "accuracy": 0.8431833386421204,
+ "mse": 0.022974206134676933
+ },
+ {
+ "epoch": 152,
+ "loss": 0.5306869149208069,
+ "accuracy": 0.8430500030517578,
+ "mse": 0.022987356409430504
+ },
+ {
+ "epoch": 153,
+ "loss": 0.5297952890396118,
+ "accuracy": 0.8432333469390869,
+ "mse": 0.022981831803917885
+ },
+ {
+ "epoch": 154,
+ "loss": 0.5291391015052795,
+ "accuracy": 0.8445666432380676,
+ "mse": 0.022861143574118614
+ },
+ {
+ "epoch": 155,
+ "loss": 0.5255391597747803,
+ "accuracy": 0.843666672706604,
+ "mse": 0.022801002487540245
+ },
+ {
+ "epoch": 156,
+ "loss": 0.5233946442604065,
+ "accuracy": 0.8447666764259338,
+ "mse": 0.022699134424328804
+ },
+ {
+ "epoch": 157,
+ "loss": 0.5212315917015076,
+ "accuracy": 0.84538334608078,
+ "mse": 0.02264176495373249
+ },
+ {
+ "epoch": 158,
+ "loss": 0.5199795961380005,
+ "accuracy": 0.8453500270843506,
+ "mse": 0.02262313850224018
+ },
+ {
+ "epoch": 159,
+ "loss": 0.5188670754432678,
+ "accuracy": 0.8461333513259888,
+ "mse": 0.022541910409927368
+ },
+ {
+ "epoch": 160,
+ "loss": 0.5169084668159485,
+ "accuracy": 0.8464000225067139,
+ "mse": 0.022431854158639908
+ },
+ {
+ "epoch": 161,
+ "loss": 0.5164435505867004,
+ "accuracy": 0.8471166491508484,
+ "mse": 0.022416239604353905
+ },
+ {
+ "epoch": 162,
+ "loss": 0.5145382285118103,
+ "accuracy": 0.8472833037376404,
+ "mse": 0.022309614345431328
+ },
+ {
+ "epoch": 163,
+ "loss": 0.5132415294647217,
+ "accuracy": 0.8483666777610779,
+ "mse": 0.022252051159739494
+ },
+ {
+ "epoch": 164,
+ "loss": 0.5093300342559814,
+ "accuracy": 0.8483833074569702,
+ "mse": 0.022103754803538322
+ },
+ {
+ "epoch": 165,
+ "loss": 0.5076257586479187,
+ "accuracy": 0.8492833375930786,
+ "mse": 0.02203282155096531
+ },
+ {
+ "epoch": 166,
+ "loss": 0.5054466128349304,
+ "accuracy": 0.8504499793052673,
+ "mse": 0.021934134885668755
+ },
+ {
+ "epoch": 167,
+ "loss": 0.5051890015602112,
+ "accuracy": 0.8506166934967041,
+ "mse": 0.021926365792751312
+ },
+ {
+ "epoch": 168,
+ "loss": 0.5037708878517151,
+ "accuracy": 0.8512833118438721,
+ "mse": 0.021832739934325218
+ },
+ {
+ "epoch": 169,
+ "loss": 0.5034052133560181,
+ "accuracy": 0.8503999710083008,
+ "mse": 0.02184033952653408
+ },
+ {
+ "epoch": 170,
+ "loss": 0.5024501085281372,
+ "accuracy": 0.8516166806221008,
+ "mse": 0.021738866344094276
+ },
+ {
+ "epoch": 171,
+ "loss": 0.4996296167373657,
+ "accuracy": 0.8518999814987183,
+ "mse": 0.02167597971856594
+ },
+ {
+ "epoch": 172,
+ "loss": 0.4975355565547943,
+ "accuracy": 0.8533666729927063,
+ "mse": 0.02151273563504219
+ },
+ {
+ "epoch": 173,
+ "loss": 0.4975355565547943,
+ "accuracy": 0.8533666729927063,
+ "mse": 0.02151273563504219
+ },
+ {
+ "epoch": 174,
+ "loss": 0.4970322847366333,
+ "accuracy": 0.8536499738693237,
+ "mse": 0.021518830209970474
+ },
+ {
+ "epoch": 175,
+ "loss": 0.4960330128669739,
+ "accuracy": 0.8544999957084656,
+ "mse": 0.02148006297647953
+ },
+ {
+ "epoch": 176,
+ "loss": 0.4939088225364685,
+ "accuracy": 0.8553000092506409,
+ "mse": 0.021456211805343628
+ },
+ {
+ "epoch": 177,
+ "loss": 0.49302297830581665,
+ "accuracy": 0.8537833094596863,
+ "mse": 0.02148415334522724
+ },
+ {
+ "epoch": 178,
+ "loss": 0.4915621876716614,
+ "accuracy": 0.8551166653633118,
+ "mse": 0.021385494619607925
+ },
+ {
+ "epoch": 179,
+ "loss": 0.49040329456329346,
+ "accuracy": 0.8550999760627747,
+ "mse": 0.021409038454294205
+ },
+ {
+ "epoch": 180,
+ "loss": 0.48863890767097473,
+ "accuracy": 0.8547000288963318,
+ "mse": 0.021347153931856155
+ },
+ {
+ "epoch": 181,
+ "loss": 0.48713845014572144,
+ "accuracy": 0.8555166721343994,
+ "mse": 0.021277396008372307
+ },
+ {
+ "epoch": 182,
+ "loss": 0.48693978786468506,
+ "accuracy": 0.85548335313797,
+ "mse": 0.021265748888254166
+ },
+ {
+ "epoch": 183,
+ "loss": 0.48591288924217224,
+ "accuracy": 0.85589998960495,
+ "mse": 0.02124720998108387
+ },
+ {
+ "epoch": 184,
+ "loss": 0.48421719670295715,
+ "accuracy": 0.8557833433151245,
+ "mse": 0.021177498623728752
+ },
+ {
+ "epoch": 185,
+ "loss": 0.48140814900398254,
+ "accuracy": 0.8571166396141052,
+ "mse": 0.021075308322906494
+ },
+ {
+ "epoch": 186,
+ "loss": 0.4812754690647125,
+ "accuracy": 0.8559333086013794,
+ "mse": 0.02118290401995182
+ },
+ {
+ "epoch": 187,
+ "loss": 0.4799172878265381,
+ "accuracy": 0.8565499782562256,
+ "mse": 0.021067969501018524
+ },
+ {
+ "epoch": 188,
+ "loss": 0.47959354519844055,
+ "accuracy": 0.8566499948501587,
+ "mse": 0.02110249362885952
+ },
+ {
+ "epoch": 189,
+ "loss": 0.47855475544929504,
+ "accuracy": 0.8561833500862122,
+ "mse": 0.02107279747724533
+ },
+ {
+ "epoch": 190,
+ "loss": 0.47757115960121155,
+ "accuracy": 0.8571000099182129,
+ "mse": 0.02100159041583538
+ },
+ {
+ "epoch": 191,
+ "loss": 0.47668787837028503,
+ "accuracy": 0.857283353805542,
+ "mse": 0.02095216140151024
+ },
+ {
+ "epoch": 192,
+ "loss": 0.47604188323020935,
+ "accuracy": 0.8578833341598511,
+ "mse": 0.020903412252664566
+ },
+ {
+ "epoch": 193,
+ "loss": 0.4749270975589752,
+ "accuracy": 0.85916668176651,
+ "mse": 0.02081945724785328
+ },
+ {
+ "epoch": 194,
+ "loss": 0.47367924451828003,
+ "accuracy": 0.8588833212852478,
+ "mse": 0.020747272297739983
+ },
+ {
+ "epoch": 195,
+ "loss": 0.47259843349456787,
+ "accuracy": 0.8596500158309937,
+ "mse": 0.02069033496081829
+ },
+ {
+ "epoch": 196,
+ "loss": 0.4725252091884613,
+ "accuracy": 0.8595166802406311,
+ "mse": 0.020674169063568115
+ },
+ {
+ "epoch": 197,
+ "loss": 0.47191596031188965,
+ "accuracy": 0.8599666953086853,
+ "mse": 0.02064516954123974
+ },
+ {
+ "epoch": 198,
+ "loss": 0.4705196022987366,
+ "accuracy": 0.8603333234786987,
+ "mse": 0.02062135562300682
+ },
+ {
+ "epoch": 199,
+ "loss": 0.4688318371772766,
+ "accuracy": 0.8611500263214111,
+ "mse": 0.020473754033446312
+ },
+ {
+ "epoch": 200,
+ "loss": 0.4686008393764496,
+ "accuracy": 0.8610333204269409,
+ "mse": 0.020526422187685966
+ },
+ {
+ "epoch": 201,
+ "loss": 0.4676390290260315,
+ "accuracy": 0.861383318901062,
+ "mse": 0.020397676154971123
+ },
+ {
+ "epoch": 202,
+ "loss": 0.46640878915786743,
+ "accuracy": 0.861299991607666,
+ "mse": 0.020403433591127396
+ },
+ {
+ "epoch": 203,
+ "loss": 0.4656824469566345,
+ "accuracy": 0.8622499704360962,
+ "mse": 0.0203250739723444
+ },
+ {
+ "epoch": 204,
+ "loss": 0.46503332257270813,
+ "accuracy": 0.8618666529655457,
+ "mse": 0.020329225808382034
+ },
+ {
+ "epoch": 205,
+ "loss": 0.4641682803630829,
+ "accuracy": 0.8620333075523376,
+ "mse": 0.02032671496272087
+ },
+ {
+ "epoch": 206,
+ "loss": 0.4635869264602661,
+ "accuracy": 0.8619666695594788,
+ "mse": 0.020304812118411064
+ },
+ {
+ "epoch": 207,
+ "loss": 0.46118274331092834,
+ "accuracy": 0.8619666695594788,
+ "mse": 0.02024197392165661
+ },
+ {
+ "epoch": 208,
+ "loss": 0.4611378312110901,
+ "accuracy": 0.8619499802589417,
+ "mse": 0.02026827074587345
+ },
+ {
+ "epoch": 209,
+ "loss": 0.46013742685317993,
+ "accuracy": 0.8630333542823792,
+ "mse": 0.020153379067778587
+ },
+ {
+ "epoch": 210,
+ "loss": 0.4589284062385559,
+ "accuracy": 0.8632833361625671,
+ "mse": 0.02016438916325569
+ },
+ {
+ "epoch": 211,
+ "loss": 0.4573846161365509,
+ "accuracy": 0.8654666543006897,
+ "mse": 0.020012959837913513
+ },
+ {
+ "epoch": 212,
+ "loss": 0.4554064869880676,
+ "accuracy": 0.8659166693687439,
+ "mse": 0.019930852577090263
+ },
+ {
+ "epoch": 213,
+ "loss": 0.4554064869880676,
+ "accuracy": 0.8659166693687439,
+ "mse": 0.019930852577090263
+ },
+ {
+ "epoch": 214,
+ "loss": 0.4553186297416687,
+ "accuracy": 0.8656333088874817,
+ "mse": 0.019919749349355698
+ },
+ {
+ "epoch": 215,
+ "loss": 0.4541488587856293,
+ "accuracy": 0.865066647529602,
+ "mse": 0.019930927082896233
+ },
+ {
+ "epoch": 216,
+ "loss": 0.45325767993927,
+ "accuracy": 0.8654166460037231,
+ "mse": 0.019898276776075363
+ },
+ {
+ "epoch": 217,
+ "loss": 0.45298153162002563,
+ "accuracy": 0.8658833503723145,
+ "mse": 0.01987488381564617
+ },
+ {
+ "epoch": 218,
+ "loss": 0.4528549611568451,
+ "accuracy": 0.8645333051681519,
+ "mse": 0.019898544996976852
+ },
+ {
+ "epoch": 219,
+ "loss": 0.4525032937526703,
+ "accuracy": 0.8651000261306763,
+ "mse": 0.019874099642038345
+ },
+ {
+ "epoch": 220,
+ "loss": 0.45222264528274536,
+ "accuracy": 0.8653833270072937,
+ "mse": 0.0198610108345747
+ },
+ {
+ "epoch": 221,
+ "loss": 0.45084506273269653,
+ "accuracy": 0.8661500215530396,
+ "mse": 0.019792310893535614
+ },
+ {
+ "epoch": 222,
+ "loss": 0.4489268958568573,
+ "accuracy": 0.8662999868392944,
+ "mse": 0.01969505287706852
+ },
+ {
+ "epoch": 223,
+ "loss": 0.4487447738647461,
+ "accuracy": 0.8664166927337646,
+ "mse": 0.019726473838090897
+ },
+ {
+ "epoch": 224,
+ "loss": 0.4486328363418579,
+ "accuracy": 0.866683304309845,
+ "mse": 0.019706953316926956
+ },
+ {
+ "epoch": 225,
+ "loss": 0.4481029212474823,
+ "accuracy": 0.8659166693687439,
+ "mse": 0.019698793068528175
+ },
+ {
+ "epoch": 226,
+ "loss": 0.4475913345813751,
+ "accuracy": 0.8665500283241272,
+ "mse": 0.019675515592098236
+ },
+ {
+ "epoch": 227,
+ "loss": 0.44573524594306946,
+ "accuracy": 0.8673833608627319,
+ "mse": 0.019556770101189613
+ },
+ {
+ "epoch": 228,
+ "loss": 0.4451221227645874,
+ "accuracy": 0.8668666481971741,
+ "mse": 0.01957458071410656
+ },
+ {
+ "epoch": 229,
+ "loss": 0.4451221227645874,
+ "accuracy": 0.8668666481971741,
+ "mse": 0.01957458071410656
+ },
+ {
+ "epoch": 230,
+ "loss": 0.4451221227645874,
+ "accuracy": 0.8668666481971741,
+ "mse": 0.01957458071410656
+ },
+ {
+ "epoch": 231,
+ "loss": 0.4451175034046173,
+ "accuracy": 0.8672333359718323,
+ "mse": 0.0195790845900774
+ },
+ {
+ "epoch": 232,
+ "loss": 0.44414445757865906,
+ "accuracy": 0.8669833540916443,
+ "mse": 0.019559146836400032
+ },
+ {
+ "epoch": 233,
+ "loss": 0.44342154264450073,
+ "accuracy": 0.8673166632652283,
+ "mse": 0.019508155062794685
+ },
+ {
+ "epoch": 234,
+ "loss": 0.4431726634502411,
+ "accuracy": 0.8674333095550537,
+ "mse": 0.019520286470651627
+ },
+ {
+ "epoch": 235,
+ "loss": 0.44160428643226624,
+ "accuracy": 0.8683333396911621,
+ "mse": 0.019429098814725876
+ },
+ {
+ "epoch": 236,
+ "loss": 0.4408556818962097,
+ "accuracy": 0.8688166737556458,
+ "mse": 0.01941310614347458
+ },
+ {
+ "epoch": 237,
+ "loss": 0.4403802156448364,
+ "accuracy": 0.8686000108718872,
+ "mse": 0.019389038905501366
+ },
+ {
+ "epoch": 238,
+ "loss": 0.4391453266143799,
+ "accuracy": 0.8690166473388672,
+ "mse": 0.01935301162302494
+ },
+ {
+ "epoch": 239,
+ "loss": 0.4387907087802887,
+ "accuracy": 0.8701000213623047,
+ "mse": 0.01930081658065319
+ },
+ {
+ "epoch": 240,
+ "loss": 0.438436359167099,
+ "accuracy": 0.8698999881744385,
+ "mse": 0.019294776022434235
+ }
+ ]
+ },
+ {
+ "seed": 72,
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "fit_time_sec": 33.7062,
+ "improvement_count": 233,
+ "last_improvement_epoch": 240,
+ "checkpoints": [
+ {
+ "epoch": 20,
+ "train_loss": 1.7392971515655518,
+ "train_acc": 0.4580833315849304,
+ "train_mse": 0.07111531496047974,
+ "test_loss": 1.7067090272903442,
+ "test_acc": 0.4602999985218048,
+ "test_mse": 0.07063549011945724
+ },
+ {
+ "epoch": 40,
+ "train_loss": 1.2618558406829834,
+ "train_acc": 0.6182666420936584,
+ "train_mse": 0.05362313985824585,
+ "test_loss": 1.2296088933944702,
+ "test_acc": 0.6273000240325928,
+ "test_mse": 0.05239206552505493
+ },
+ {
+ "epoch": 60,
+ "train_loss": 0.9506728053092957,
+ "train_acc": 0.7125833630561829,
+ "train_mse": 0.04073568433523178,
+ "test_loss": 0.90444415807724,
+ "test_acc": 0.725600004196167,
+ "test_mse": 0.03892349451780319
+ },
+ {
+ "epoch": 80,
+ "train_loss": 0.7690414786338806,
+ "train_acc": 0.7677000164985657,
+ "train_mse": 0.0332583524286747,
+ "test_loss": 0.7225316762924194,
+ "test_acc": 0.7825000286102295,
+ "test_mse": 0.03151436522603035
+ },
+ {
+ "epoch": 100,
+ "train_loss": 0.6607407331466675,
+ "train_acc": 0.7977833151817322,
+ "train_mse": 0.029053399339318275,
+ "test_loss": 0.6213417053222656,
+ "test_acc": 0.8091999888420105,
+ "test_mse": 0.02738099917769432
+ },
+ {
+ "epoch": 120,
+ "train_loss": 0.5884125232696533,
+ "train_acc": 0.8225333094596863,
+ "train_mse": 0.02557925134897232,
+ "test_loss": 0.5514547824859619,
+ "test_acc": 0.8324999809265137,
+ "test_mse": 0.024056605994701385
+ },
+ {
+ "epoch": 140,
+ "train_loss": 0.5509796142578125,
+ "train_acc": 0.8328999876976013,
+ "train_mse": 0.02395990863442421,
+ "test_loss": 0.5114421844482422,
+ "test_acc": 0.8463000059127808,
+ "test_mse": 0.022018717601895332
+ },
+ {
+ "epoch": 160,
+ "train_loss": 0.5122449398040771,
+ "train_acc": 0.8464499711990356,
+ "train_mse": 0.022468935698270798,
+ "test_loss": 0.4830068349838257,
+ "test_acc": 0.8574000000953674,
+ "test_mse": 0.021029997617006302
+ },
+ {
+ "epoch": 180,
+ "train_loss": 0.4828203022480011,
+ "train_acc": 0.8543833494186401,
+ "train_mse": 0.021225325763225555,
+ "test_loss": 0.45465460419654846,
+ "test_acc": 0.8646000027656555,
+ "test_mse": 0.01990104280412197
+ },
+ {
+ "epoch": 200,
+ "train_loss": 0.46293872594833374,
+ "train_acc": 0.8621000051498413,
+ "train_mse": 0.020341966301202774,
+ "test_loss": 0.4369881749153137,
+ "test_acc": 0.8700000047683716,
+ "test_mse": 0.019186409190297127
+ },
+ {
+ "epoch": 220,
+ "train_loss": 0.4459497630596161,
+ "train_acc": 0.8664166927337646,
+ "train_mse": 0.0197211392223835,
+ "test_loss": 0.41942450404167175,
+ "test_acc": 0.8730000257492065,
+ "test_mse": 0.0184775423258543
+ },
+ {
+ "epoch": 240,
+ "train_loss": 0.4350419342517853,
+ "train_acc": 0.871566653251648,
+ "train_mse": 0.01916772872209549,
+ "test_loss": 0.41060513257980347,
+ "test_acc": 0.875,
+ "test_mse": 0.018150048330426216
+ }
+ ],
+ "completed": true,
+ "error": null,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "epoch_history": [
+ {
+ "epoch": 1,
+ "loss": 2.394867181777954,
+ "accuracy": 0.12068333476781845,
+ "mse": 0.09222322702407837
+ },
+ {
+ "epoch": 2,
+ "loss": 2.3721373081207275,
+ "accuracy": 0.17710000276565552,
+ "mse": 0.09110955148935318
+ },
+ {
+ "epoch": 3,
+ "loss": 2.313584327697754,
+ "accuracy": 0.1745000034570694,
+ "mse": 0.09007149934768677
+ },
+ {
+ "epoch": 4,
+ "loss": 2.2822771072387695,
+ "accuracy": 0.1851833313703537,
+ "mse": 0.08958881348371506
+ },
+ {
+ "epoch": 5,
+ "loss": 2.2472145557403564,
+ "accuracy": 0.19448333978652954,
+ "mse": 0.08932461589574814
+ },
+ {
+ "epoch": 6,
+ "loss": 2.194371461868286,
+ "accuracy": 0.22210000455379486,
+ "mse": 0.08808117359876633
+ },
+ {
+ "epoch": 7,
+ "loss": 2.1225574016571045,
+ "accuracy": 0.26155000925064087,
+ "mse": 0.08639317005872726
+ },
+ {
+ "epoch": 8,
+ "loss": 2.1065263748168945,
+ "accuracy": 0.257099986076355,
+ "mse": 0.08618183434009552
+ },
+ {
+ "epoch": 9,
+ "loss": 2.073214292526245,
+ "accuracy": 0.2905333340167999,
+ "mse": 0.08590386807918549
+ },
+ {
+ "epoch": 10,
+ "loss": 2.051462173461914,
+ "accuracy": 0.2962999939918518,
+ "mse": 0.0854872539639473
+ },
+ {
+ "epoch": 11,
+ "loss": 2.0312182903289795,
+ "accuracy": 0.3112666606903076,
+ "mse": 0.08377041667699814
+ },
+ {
+ "epoch": 12,
+ "loss": 1.9965864419937134,
+ "accuracy": 0.3146333396434784,
+ "mse": 0.08336399495601654
+ },
+ {
+ "epoch": 13,
+ "loss": 1.9561365842819214,
+ "accuracy": 0.3281833231449127,
+ "mse": 0.08182694017887115
+ },
+ {
+ "epoch": 14,
+ "loss": 1.9114563465118408,
+ "accuracy": 0.35245001316070557,
+ "mse": 0.07964485883712769
+ },
+ {
+ "epoch": 15,
+ "loss": 1.8931968212127686,
+ "accuracy": 0.3644333481788635,
+ "mse": 0.07877293229103088
+ },
+ {
+ "epoch": 16,
+ "loss": 1.8586288690567017,
+ "accuracy": 0.384550005197525,
+ "mse": 0.07726404815912247
+ },
+ {
+ "epoch": 17,
+ "loss": 1.8215407133102417,
+ "accuracy": 0.4031499922275543,
+ "mse": 0.07585567981004715
+ },
+ {
+ "epoch": 18,
+ "loss": 1.7806206941604614,
+ "accuracy": 0.4261833429336548,
+ "mse": 0.07360883057117462
+ },
+ {
+ "epoch": 19,
+ "loss": 1.762655258178711,
+ "accuracy": 0.43924999237060547,
+ "mse": 0.07294169813394547
+ },
+ {
+ "epoch": 20,
+ "loss": 1.7392971515655518,
+ "accuracy": 0.4580833315849304,
+ "mse": 0.07111531496047974
+ },
+ {
+ "epoch": 21,
+ "loss": 1.7061707973480225,
+ "accuracy": 0.4684000015258789,
+ "mse": 0.0700707957148552
+ },
+ {
+ "epoch": 22,
+ "loss": 1.6878095865249634,
+ "accuracy": 0.47983333468437195,
+ "mse": 0.06908378005027771
+ },
+ {
+ "epoch": 23,
+ "loss": 1.6603877544403076,
+ "accuracy": 0.4860000014305115,
+ "mse": 0.06851949542760849
+ },
+ {
+ "epoch": 24,
+ "loss": 1.6157729625701904,
+ "accuracy": 0.5046499967575073,
+ "mse": 0.0663679912686348
+ },
+ {
+ "epoch": 25,
+ "loss": 1.5901435613632202,
+ "accuracy": 0.5048333406448364,
+ "mse": 0.06646105647087097
+ },
+ {
+ "epoch": 26,
+ "loss": 1.5558902025222778,
+ "accuracy": 0.5153833627700806,
+ "mse": 0.06508835405111313
+ },
+ {
+ "epoch": 27,
+ "loss": 1.533032774925232,
+ "accuracy": 0.5198500156402588,
+ "mse": 0.06450068950653076
+ },
+ {
+ "epoch": 28,
+ "loss": 1.503989815711975,
+ "accuracy": 0.5273000001907349,
+ "mse": 0.06395094841718674
+ },
+ {
+ "epoch": 29,
+ "loss": 1.477220058441162,
+ "accuracy": 0.5357999801635742,
+ "mse": 0.06262895464897156
+ },
+ {
+ "epoch": 30,
+ "loss": 1.4620596170425415,
+ "accuracy": 0.5351999998092651,
+ "mse": 0.06263303011655807
+ },
+ {
+ "epoch": 31,
+ "loss": 1.4134670495986938,
+ "accuracy": 0.5614500045776367,
+ "mse": 0.06020600348711014
+ },
+ {
+ "epoch": 32,
+ "loss": 1.4016313552856445,
+ "accuracy": 0.5632500052452087,
+ "mse": 0.059774428606033325
+ },
+ {
+ "epoch": 33,
+ "loss": 1.3814622163772583,
+ "accuracy": 0.5680500268936157,
+ "mse": 0.05823231115937233
+ },
+ {
+ "epoch": 34,
+ "loss": 1.345603108406067,
+ "accuracy": 0.5861999988555908,
+ "mse": 0.05717482417821884
+ },
+ {
+ "epoch": 35,
+ "loss": 1.345603108406067,
+ "accuracy": 0.5861999988555908,
+ "mse": 0.05717482417821884
+ },
+ {
+ "epoch": 36,
+ "loss": 1.3308271169662476,
+ "accuracy": 0.5940666794776917,
+ "mse": 0.056432344019412994
+ },
+ {
+ "epoch": 37,
+ "loss": 1.3158366680145264,
+ "accuracy": 0.5978166460990906,
+ "mse": 0.05572309345006943
+ },
+ {
+ "epoch": 38,
+ "loss": 1.3060545921325684,
+ "accuracy": 0.6017500162124634,
+ "mse": 0.05550236254930496
+ },
+ {
+ "epoch": 39,
+ "loss": 1.2716864347457886,
+ "accuracy": 0.6170833110809326,
+ "mse": 0.05347517505288124
+ },
+ {
+ "epoch": 40,
+ "loss": 1.2618558406829834,
+ "accuracy": 0.6182666420936584,
+ "mse": 0.05362313985824585
+ },
+ {
+ "epoch": 41,
+ "loss": 1.2458807229995728,
+ "accuracy": 0.6244000196456909,
+ "mse": 0.05271847918629646
+ },
+ {
+ "epoch": 42,
+ "loss": 1.2163281440734863,
+ "accuracy": 0.6350666880607605,
+ "mse": 0.0515204481780529
+ },
+ {
+ "epoch": 43,
+ "loss": 1.1991400718688965,
+ "accuracy": 0.6421166658401489,
+ "mse": 0.050657644867897034
+ },
+ {
+ "epoch": 44,
+ "loss": 1.1815896034240723,
+ "accuracy": 0.6452333331108093,
+ "mse": 0.05007390305399895
+ },
+ {
+ "epoch": 45,
+ "loss": 1.176984429359436,
+ "accuracy": 0.6482333540916443,
+ "mse": 0.04978104680776596
+ },
+ {
+ "epoch": 46,
+ "loss": 1.1602901220321655,
+ "accuracy": 0.6504499912261963,
+ "mse": 0.04939280450344086
+ },
+ {
+ "epoch": 47,
+ "loss": 1.1487879753112793,
+ "accuracy": 0.652999997138977,
+ "mse": 0.048812948167324066
+ },
+ {
+ "epoch": 48,
+ "loss": 1.1169127225875854,
+ "accuracy": 0.6624333262443542,
+ "mse": 0.047551464289426804
+ },
+ {
+ "epoch": 49,
+ "loss": 1.0957636833190918,
+ "accuracy": 0.6663166880607605,
+ "mse": 0.047307971864938736
+ },
+ {
+ "epoch": 50,
+ "loss": 1.0824836492538452,
+ "accuracy": 0.6706166863441467,
+ "mse": 0.04635510966181755
+ },
+ {
+ "epoch": 51,
+ "loss": 1.0697671175003052,
+ "accuracy": 0.6743166446685791,
+ "mse": 0.04611103609204292
+ },
+ {
+ "epoch": 52,
+ "loss": 1.057702660560608,
+ "accuracy": 0.6814333200454712,
+ "mse": 0.045103445649147034
+ },
+ {
+ "epoch": 53,
+ "loss": 1.035702109336853,
+ "accuracy": 0.6859999895095825,
+ "mse": 0.04450591653585434
+ },
+ {
+ "epoch": 54,
+ "loss": 1.0215198993682861,
+ "accuracy": 0.691516637802124,
+ "mse": 0.043842166662216187
+ },
+ {
+ "epoch": 55,
+ "loss": 1.0144044160842896,
+ "accuracy": 0.6957833170890808,
+ "mse": 0.04337666183710098
+ },
+ {
+ "epoch": 56,
+ "loss": 1.0002727508544922,
+ "accuracy": 0.6985833048820496,
+ "mse": 0.04289008304476738
+ },
+ {
+ "epoch": 57,
+ "loss": 0.9921114444732666,
+ "accuracy": 0.7012666463851929,
+ "mse": 0.04237997159361839
+ },
+ {
+ "epoch": 58,
+ "loss": 0.9806033968925476,
+ "accuracy": 0.7028833627700806,
+ "mse": 0.042033515870571136
+ },
+ {
+ "epoch": 59,
+ "loss": 0.9632399678230286,
+ "accuracy": 0.7085833549499512,
+ "mse": 0.04124509170651436
+ },
+ {
+ "epoch": 60,
+ "loss": 0.9506728053092957,
+ "accuracy": 0.7125833630561829,
+ "mse": 0.04073568433523178
+ },
+ {
+ "epoch": 61,
+ "loss": 0.9407740831375122,
+ "accuracy": 0.7153000235557556,
+ "mse": 0.040367208421230316
+ },
+ {
+ "epoch": 62,
+ "loss": 0.9084635376930237,
+ "accuracy": 0.724133312702179,
+ "mse": 0.039161745458841324
+ },
+ {
+ "epoch": 63,
+ "loss": 0.8980634212493896,
+ "accuracy": 0.7280166745185852,
+ "mse": 0.03858596831560135
+ },
+ {
+ "epoch": 64,
+ "loss": 0.8962931632995605,
+ "accuracy": 0.728683352470398,
+ "mse": 0.038825131952762604
+ },
+ {
+ "epoch": 65,
+ "loss": 0.8922550678253174,
+ "accuracy": 0.728950023651123,
+ "mse": 0.03852137178182602
+ },
+ {
+ "epoch": 66,
+ "loss": 0.8826940059661865,
+ "accuracy": 0.734000027179718,
+ "mse": 0.03802183270454407
+ },
+ {
+ "epoch": 67,
+ "loss": 0.8747583627700806,
+ "accuracy": 0.7340166568756104,
+ "mse": 0.03772991523146629
+ },
+ {
+ "epoch": 68,
+ "loss": 0.8644124865531921,
+ "accuracy": 0.7387999892234802,
+ "mse": 0.03730497881770134
+ },
+ {
+ "epoch": 69,
+ "loss": 0.8539621233940125,
+ "accuracy": 0.7418833374977112,
+ "mse": 0.03676025941967964
+ },
+ {
+ "epoch": 70,
+ "loss": 0.8444147109985352,
+ "accuracy": 0.7439000010490417,
+ "mse": 0.03647427633404732
+ },
+ {
+ "epoch": 71,
+ "loss": 0.8361355662345886,
+ "accuracy": 0.7472333312034607,
+ "mse": 0.03591616451740265
+ },
+ {
+ "epoch": 72,
+ "loss": 0.8286452889442444,
+ "accuracy": 0.7506666779518127,
+ "mse": 0.035745132714509964
+ },
+ {
+ "epoch": 73,
+ "loss": 0.8206419348716736,
+ "accuracy": 0.751716673374176,
+ "mse": 0.03539096191525459
+ },
+ {
+ "epoch": 74,
+ "loss": 0.8129788637161255,
+ "accuracy": 0.7555999755859375,
+ "mse": 0.035013824701309204
+ },
+ {
+ "epoch": 75,
+ "loss": 0.8059999942779541,
+ "accuracy": 0.7592499852180481,
+ "mse": 0.03461651876568794
+ },
+ {
+ "epoch": 76,
+ "loss": 0.7961980104446411,
+ "accuracy": 0.759850025177002,
+ "mse": 0.03440691903233528
+ },
+ {
+ "epoch": 77,
+ "loss": 0.7882765531539917,
+ "accuracy": 0.763949990272522,
+ "mse": 0.033924974501132965
+ },
+ {
+ "epoch": 78,
+ "loss": 0.7809193730354309,
+ "accuracy": 0.7643166780471802,
+ "mse": 0.03382163494825363
+ },
+ {
+ "epoch": 79,
+ "loss": 0.7755311131477356,
+ "accuracy": 0.7668833136558533,
+ "mse": 0.033399548381567
+ },
+ {
+ "epoch": 80,
+ "loss": 0.7690414786338806,
+ "accuracy": 0.7677000164985657,
+ "mse": 0.0332583524286747
+ },
+ {
+ "epoch": 81,
+ "loss": 0.7634834051132202,
+ "accuracy": 0.7707499861717224,
+ "mse": 0.03295470029115677
+ },
+ {
+ "epoch": 82,
+ "loss": 0.7608415484428406,
+ "accuracy": 0.7707833051681519,
+ "mse": 0.03282611817121506
+ },
+ {
+ "epoch": 83,
+ "loss": 0.7531490921974182,
+ "accuracy": 0.7729499936103821,
+ "mse": 0.03264449164271355
+ },
+ {
+ "epoch": 84,
+ "loss": 0.7439812421798706,
+ "accuracy": 0.7767000198364258,
+ "mse": 0.03218987584114075
+ },
+ {
+ "epoch": 85,
+ "loss": 0.7391633987426758,
+ "accuracy": 0.7764833569526672,
+ "mse": 0.03212250769138336
+ },
+ {
+ "epoch": 86,
+ "loss": 0.7286661267280579,
+ "accuracy": 0.7799500226974487,
+ "mse": 0.03149685263633728
+ },
+ {
+ "epoch": 87,
+ "loss": 0.7204961776733398,
+ "accuracy": 0.7805333137512207,
+ "mse": 0.03136414289474487
+ },
+ {
+ "epoch": 88,
+ "loss": 0.7151843905448914,
+ "accuracy": 0.781416654586792,
+ "mse": 0.031125931069254875
+ },
+ {
+ "epoch": 89,
+ "loss": 0.7130192518234253,
+ "accuracy": 0.7816666960716248,
+ "mse": 0.031036878004670143
+ },
+ {
+ "epoch": 90,
+ "loss": 0.7002984285354614,
+ "accuracy": 0.7861833572387695,
+ "mse": 0.030584359541535378
+ },
+ {
+ "epoch": 91,
+ "loss": 0.6964454054832458,
+ "accuracy": 0.786050021648407,
+ "mse": 0.03042665496468544
+ },
+ {
+ "epoch": 92,
+ "loss": 0.6906138062477112,
+ "accuracy": 0.7889500260353088,
+ "mse": 0.03022131137549877
+ },
+ {
+ "epoch": 93,
+ "loss": 0.6875464916229248,
+ "accuracy": 0.7890666723251343,
+ "mse": 0.030158404260873795
+ },
+ {
+ "epoch": 94,
+ "loss": 0.6844578385353088,
+ "accuracy": 0.7905333042144775,
+ "mse": 0.029996277764439583
+ },
+ {
+ "epoch": 95,
+ "loss": 0.6801095008850098,
+ "accuracy": 0.791366696357727,
+ "mse": 0.029878007248044014
+ },
+ {
+ "epoch": 96,
+ "loss": 0.6754758358001709,
+ "accuracy": 0.7952499985694885,
+ "mse": 0.029521800577640533
+ },
+ {
+ "epoch": 97,
+ "loss": 0.6739013195037842,
+ "accuracy": 0.7954333424568176,
+ "mse": 0.029485946521162987
+ },
+ {
+ "epoch": 98,
+ "loss": 0.6691822409629822,
+ "accuracy": 0.795366644859314,
+ "mse": 0.02930469438433647
+ },
+ {
+ "epoch": 99,
+ "loss": 0.6667131781578064,
+ "accuracy": 0.7972999811172485,
+ "mse": 0.029211752116680145
+ },
+ {
+ "epoch": 100,
+ "loss": 0.6607407331466675,
+ "accuracy": 0.7977833151817322,
+ "mse": 0.029053399339318275
+ },
+ {
+ "epoch": 101,
+ "loss": 0.6544605493545532,
+ "accuracy": 0.7992833256721497,
+ "mse": 0.028714003041386604
+ },
+ {
+ "epoch": 102,
+ "loss": 0.6505080461502075,
+ "accuracy": 0.8024166822433472,
+ "mse": 0.028444843366742134
+ },
+ {
+ "epoch": 103,
+ "loss": 0.6443454623222351,
+ "accuracy": 0.8034999966621399,
+ "mse": 0.0282574649900198
+ },
+ {
+ "epoch": 104,
+ "loss": 0.6419376730918884,
+ "accuracy": 0.8034499883651733,
+ "mse": 0.028164325281977654
+ },
+ {
+ "epoch": 105,
+ "loss": 0.6383581757545471,
+ "accuracy": 0.8055166602134705,
+ "mse": 0.02793096750974655
+ },
+ {
+ "epoch": 106,
+ "loss": 0.6342165470123291,
+ "accuracy": 0.807616651058197,
+ "mse": 0.027710596099495888
+ },
+ {
+ "epoch": 107,
+ "loss": 0.6329084038734436,
+ "accuracy": 0.8089166879653931,
+ "mse": 0.027554696425795555
+ },
+ {
+ "epoch": 108,
+ "loss": 0.626007080078125,
+ "accuracy": 0.8116333484649658,
+ "mse": 0.027184829115867615
+ },
+ {
+ "epoch": 109,
+ "loss": 0.6228019595146179,
+ "accuracy": 0.8125333189964294,
+ "mse": 0.027057042345404625
+ },
+ {
+ "epoch": 110,
+ "loss": 0.6187105178833008,
+ "accuracy": 0.8132833242416382,
+ "mse": 0.026842202991247177
+ },
+ {
+ "epoch": 111,
+ "loss": 0.6187105178833008,
+ "accuracy": 0.8132833242416382,
+ "mse": 0.026842202991247177
+ },
+ {
+ "epoch": 112,
+ "loss": 0.6174106597900391,
+ "accuracy": 0.8139333128929138,
+ "mse": 0.02677645906805992
+ },
+ {
+ "epoch": 113,
+ "loss": 0.6151530146598816,
+ "accuracy": 0.8144999742507935,
+ "mse": 0.02668280526995659
+ },
+ {
+ "epoch": 114,
+ "loss": 0.6099346876144409,
+ "accuracy": 0.8156166672706604,
+ "mse": 0.026437148451805115
+ },
+ {
+ "epoch": 115,
+ "loss": 0.6066809892654419,
+ "accuracy": 0.8163833618164062,
+ "mse": 0.02630719728767872
+ },
+ {
+ "epoch": 116,
+ "loss": 0.6029501557350159,
+ "accuracy": 0.8180333375930786,
+ "mse": 0.026130348443984985
+ },
+ {
+ "epoch": 117,
+ "loss": 0.5999534726142883,
+ "accuracy": 0.8183500170707703,
+ "mse": 0.026076067239046097
+ },
+ {
+ "epoch": 118,
+ "loss": 0.5965328812599182,
+ "accuracy": 0.8193333148956299,
+ "mse": 0.025985311716794968
+ },
+ {
+ "epoch": 119,
+ "loss": 0.5911880135536194,
+ "accuracy": 0.821483314037323,
+ "mse": 0.025662539526820183
+ },
+ {
+ "epoch": 120,
+ "loss": 0.5884125232696533,
+ "accuracy": 0.8225333094596863,
+ "mse": 0.02557925134897232
+ },
+ {
+ "epoch": 121,
+ "loss": 0.5876928567886353,
+ "accuracy": 0.8223166465759277,
+ "mse": 0.025591829791665077
+ },
+ {
+ "epoch": 122,
+ "loss": 0.586211085319519,
+ "accuracy": 0.8217499852180481,
+ "mse": 0.025496438145637512
+ },
+ {
+ "epoch": 123,
+ "loss": 0.5836067795753479,
+ "accuracy": 0.8234000205993652,
+ "mse": 0.025367969647049904
+ },
+ {
+ "epoch": 124,
+ "loss": 0.5805411338806152,
+ "accuracy": 0.8237500190734863,
+ "mse": 0.025221845135092735
+ },
+ {
+ "epoch": 125,
+ "loss": 0.5787683129310608,
+ "accuracy": 0.8248000144958496,
+ "mse": 0.025159157812595367
+ },
+ {
+ "epoch": 126,
+ "loss": 0.5765712261199951,
+ "accuracy": 0.8253333568572998,
+ "mse": 0.025015030056238174
+ },
+ {
+ "epoch": 127,
+ "loss": 0.5726543068885803,
+ "accuracy": 0.8250666856765747,
+ "mse": 0.02495999075472355
+ },
+ {
+ "epoch": 128,
+ "loss": 0.5722291469573975,
+ "accuracy": 0.8253999948501587,
+ "mse": 0.024870775640010834
+ },
+ {
+ "epoch": 129,
+ "loss": 0.5714932680130005,
+ "accuracy": 0.8254500031471252,
+ "mse": 0.024888642132282257
+ },
+ {
+ "epoch": 130,
+ "loss": 0.5696581602096558,
+ "accuracy": 0.8263999819755554,
+ "mse": 0.02477351389825344
+ },
+ {
+ "epoch": 131,
+ "loss": 0.5667762756347656,
+ "accuracy": 0.8267999887466431,
+ "mse": 0.024728277698159218
+ },
+ {
+ "epoch": 132,
+ "loss": 0.563697338104248,
+ "accuracy": 0.8287833333015442,
+ "mse": 0.02454882673919201
+ },
+ {
+ "epoch": 133,
+ "loss": 0.5627124309539795,
+ "accuracy": 0.8290666937828064,
+ "mse": 0.024489495903253555
+ },
+ {
+ "epoch": 134,
+ "loss": 0.5605831742286682,
+ "accuracy": 0.829800009727478,
+ "mse": 0.024389678612351418
+ },
+ {
+ "epoch": 135,
+ "loss": 0.5593191385269165,
+ "accuracy": 0.8307833075523376,
+ "mse": 0.024331802502274513
+ },
+ {
+ "epoch": 136,
+ "loss": 0.5583140850067139,
+ "accuracy": 0.8299499750137329,
+ "mse": 0.02431635744869709
+ },
+ {
+ "epoch": 137,
+ "loss": 0.5569862127304077,
+ "accuracy": 0.8313833475112915,
+ "mse": 0.024272216483950615
+ },
+ {
+ "epoch": 138,
+ "loss": 0.5539029240608215,
+ "accuracy": 0.8325333595275879,
+ "mse": 0.024042081087827682
+ },
+ {
+ "epoch": 139,
+ "loss": 0.5527498722076416,
+ "accuracy": 0.8321833610534668,
+ "mse": 0.02401621825993061
+ },
+ {
+ "epoch": 140,
+ "loss": 0.5509796142578125,
+ "accuracy": 0.8328999876976013,
+ "mse": 0.02395990863442421
+ },
+ {
+ "epoch": 141,
+ "loss": 0.5475168824195862,
+ "accuracy": 0.8342833518981934,
+ "mse": 0.023850848898291588
+ },
+ {
+ "epoch": 142,
+ "loss": 0.5448682904243469,
+ "accuracy": 0.8346499800682068,
+ "mse": 0.023759927600622177
+ },
+ {
+ "epoch": 143,
+ "loss": 0.5433222651481628,
+ "accuracy": 0.8339666724205017,
+ "mse": 0.023750443011522293
+ },
+ {
+ "epoch": 144,
+ "loss": 0.5409438014030457,
+ "accuracy": 0.8360833525657654,
+ "mse": 0.023647366091609
+ },
+ {
+ "epoch": 145,
+ "loss": 0.5389690399169922,
+ "accuracy": 0.8360666632652283,
+ "mse": 0.023602688685059547
+ },
+ {
+ "epoch": 146,
+ "loss": 0.536476731300354,
+ "accuracy": 0.8360999822616577,
+ "mse": 0.023510251194238663
+ },
+ {
+ "epoch": 147,
+ "loss": 0.5354729890823364,
+ "accuracy": 0.8367499709129333,
+ "mse": 0.023435726761817932
+ },
+ {
+ "epoch": 148,
+ "loss": 0.532624363899231,
+ "accuracy": 0.8377833366394043,
+ "mse": 0.02336377650499344
+ },
+ {
+ "epoch": 149,
+ "loss": 0.5315098166465759,
+ "accuracy": 0.838283360004425,
+ "mse": 0.023280519992113113
+ },
+ {
+ "epoch": 150,
+ "loss": 0.5296294689178467,
+ "accuracy": 0.8389666676521301,
+ "mse": 0.02330147475004196
+ },
+ {
+ "epoch": 151,
+ "loss": 0.5274991393089294,
+ "accuracy": 0.8389833569526672,
+ "mse": 0.023200638592243195
+ },
+ {
+ "epoch": 152,
+ "loss": 0.5266032814979553,
+ "accuracy": 0.839900016784668,
+ "mse": 0.02314605750143528
+ },
+ {
+ "epoch": 153,
+ "loss": 0.5227481722831726,
+ "accuracy": 0.8403333425521851,
+ "mse": 0.023036884143948555
+ },
+ {
+ "epoch": 154,
+ "loss": 0.5206952095031738,
+ "accuracy": 0.841949999332428,
+ "mse": 0.022865088656544685
+ },
+ {
+ "epoch": 155,
+ "loss": 0.5183946490287781,
+ "accuracy": 0.8422666788101196,
+ "mse": 0.022777164354920387
+ },
+ {
+ "epoch": 156,
+ "loss": 0.5168766975402832,
+ "accuracy": 0.8437166810035706,
+ "mse": 0.02267194353044033
+ },
+ {
+ "epoch": 157,
+ "loss": 0.5158666372299194,
+ "accuracy": 0.8443666696548462,
+ "mse": 0.022626474499702454
+ },
+ {
+ "epoch": 158,
+ "loss": 0.5148171186447144,
+ "accuracy": 0.8450833559036255,
+ "mse": 0.022579144686460495
+ },
+ {
+ "epoch": 159,
+ "loss": 0.514457643032074,
+ "accuracy": 0.8450833559036255,
+ "mse": 0.022574029862880707
+ },
+ {
+ "epoch": 160,
+ "loss": 0.5122449398040771,
+ "accuracy": 0.8464499711990356,
+ "mse": 0.022468935698270798
+ },
+ {
+ "epoch": 161,
+ "loss": 0.5111017823219299,
+ "accuracy": 0.8465833067893982,
+ "mse": 0.02237522415816784
+ },
+ {
+ "epoch": 162,
+ "loss": 0.5098553895950317,
+ "accuracy": 0.8481333255767822,
+ "mse": 0.02232295647263527
+ },
+ {
+ "epoch": 163,
+ "loss": 0.5059186220169067,
+ "accuracy": 0.8478500247001648,
+ "mse": 0.022167028859257698
+ },
+ {
+ "epoch": 164,
+ "loss": 0.5051796436309814,
+ "accuracy": 0.8488166928291321,
+ "mse": 0.022147024050354958
+ },
+ {
+ "epoch": 165,
+ "loss": 0.5029154419898987,
+ "accuracy": 0.849049985408783,
+ "mse": 0.02201830968260765
+ },
+ {
+ "epoch": 166,
+ "loss": 0.5022867321968079,
+ "accuracy": 0.8499166369438171,
+ "mse": 0.022001594305038452
+ },
+ {
+ "epoch": 167,
+ "loss": 0.5006119608879089,
+ "accuracy": 0.849566638469696,
+ "mse": 0.022000493481755257
+ },
+ {
+ "epoch": 168,
+ "loss": 0.4991479218006134,
+ "accuracy": 0.8508166670799255,
+ "mse": 0.021896883845329285
+ },
+ {
+ "epoch": 169,
+ "loss": 0.49703511595726013,
+ "accuracy": 0.8509166836738586,
+ "mse": 0.021842772141098976
+ },
+ {
+ "epoch": 170,
+ "loss": 0.49615880846977234,
+ "accuracy": 0.8509833216667175,
+ "mse": 0.02179141715168953
+ },
+ {
+ "epoch": 171,
+ "loss": 0.49429014325141907,
+ "accuracy": 0.8519333600997925,
+ "mse": 0.02165626548230648
+ },
+ {
+ "epoch": 172,
+ "loss": 0.49275872111320496,
+ "accuracy": 0.8522166609764099,
+ "mse": 0.02160441316664219
+ },
+ {
+ "epoch": 173,
+ "loss": 0.49195852875709534,
+ "accuracy": 0.8521333336830139,
+ "mse": 0.02157740481197834
+ },
+ {
+ "epoch": 174,
+ "loss": 0.49124792218208313,
+ "accuracy": 0.8524500131607056,
+ "mse": 0.02157047763466835
+ },
+ {
+ "epoch": 175,
+ "loss": 0.4901835024356842,
+ "accuracy": 0.8530833125114441,
+ "mse": 0.021508440375328064
+ },
+ {
+ "epoch": 176,
+ "loss": 0.4891456365585327,
+ "accuracy": 0.853600025177002,
+ "mse": 0.02148490585386753
+ },
+ {
+ "epoch": 177,
+ "loss": 0.48769453167915344,
+ "accuracy": 0.8532666563987732,
+ "mse": 0.021480074152350426
+ },
+ {
+ "epoch": 178,
+ "loss": 0.48527172207832336,
+ "accuracy": 0.8537833094596863,
+ "mse": 0.021328840404748917
+ },
+ {
+ "epoch": 179,
+ "loss": 0.48428502678871155,
+ "accuracy": 0.8544166684150696,
+ "mse": 0.021304914727807045
+ },
+ {
+ "epoch": 180,
+ "loss": 0.4828203022480011,
+ "accuracy": 0.8543833494186401,
+ "mse": 0.021225325763225555
+ },
+ {
+ "epoch": 181,
+ "loss": 0.4811919331550598,
+ "accuracy": 0.8553500175476074,
+ "mse": 0.021144112572073936
+ },
+ {
+ "epoch": 182,
+ "loss": 0.47966477274894714,
+ "accuracy": 0.8555833101272583,
+ "mse": 0.021064091473817825
+ },
+ {
+ "epoch": 183,
+ "loss": 0.47966477274894714,
+ "accuracy": 0.8555833101272583,
+ "mse": 0.021064091473817825
+ },
+ {
+ "epoch": 184,
+ "loss": 0.4787598252296448,
+ "accuracy": 0.8569166660308838,
+ "mse": 0.021019967272877693
+ },
+ {
+ "epoch": 185,
+ "loss": 0.47772958874702454,
+ "accuracy": 0.8567833304405212,
+ "mse": 0.02099861577153206
+ },
+ {
+ "epoch": 186,
+ "loss": 0.4758150279521942,
+ "accuracy": 0.8571000099182129,
+ "mse": 0.02093137428164482
+ },
+ {
+ "epoch": 187,
+ "loss": 0.47504228353500366,
+ "accuracy": 0.8585333228111267,
+ "mse": 0.020878314971923828
+ },
+ {
+ "epoch": 188,
+ "loss": 0.47322753071784973,
+ "accuracy": 0.8584499955177307,
+ "mse": 0.02082100510597229
+ },
+ {
+ "epoch": 189,
+ "loss": 0.4715079665184021,
+ "accuracy": 0.8599333167076111,
+ "mse": 0.0207208301872015
+ },
+ {
+ "epoch": 190,
+ "loss": 0.4701905846595764,
+ "accuracy": 0.8605499863624573,
+ "mse": 0.020633727312088013
+ },
+ {
+ "epoch": 191,
+ "loss": 0.4701905846595764,
+ "accuracy": 0.8605499863624573,
+ "mse": 0.020633727312088013
+ },
+ {
+ "epoch": 192,
+ "loss": 0.4693160355091095,
+ "accuracy": 0.8608333468437195,
+ "mse": 0.020603593438863754
+ },
+ {
+ "epoch": 193,
+ "loss": 0.4687773585319519,
+ "accuracy": 0.8612666726112366,
+ "mse": 0.02057836391031742
+ },
+ {
+ "epoch": 194,
+ "loss": 0.46789446473121643,
+ "accuracy": 0.8611833453178406,
+ "mse": 0.02054569683969021
+ },
+ {
+ "epoch": 195,
+ "loss": 0.4675624966621399,
+ "accuracy": 0.8618999719619751,
+ "mse": 0.020536115393042564
+ },
+ {
+ "epoch": 196,
+ "loss": 0.4659227132797241,
+ "accuracy": 0.8620666861534119,
+ "mse": 0.020450910553336143
+ },
+ {
+ "epoch": 197,
+ "loss": 0.4650554955005646,
+ "accuracy": 0.8619666695594788,
+ "mse": 0.02041606791317463
+ },
+ {
+ "epoch": 198,
+ "loss": 0.464699387550354,
+ "accuracy": 0.8623833060264587,
+ "mse": 0.020427461713552475
+ },
+ {
+ "epoch": 199,
+ "loss": 0.46361732482910156,
+ "accuracy": 0.8625500202178955,
+ "mse": 0.020369675010442734
+ },
+ {
+ "epoch": 200,
+ "loss": 0.46293872594833374,
+ "accuracy": 0.8621000051498413,
+ "mse": 0.020341966301202774
+ },
+ {
+ "epoch": 201,
+ "loss": 0.4616846442222595,
+ "accuracy": 0.8624833226203918,
+ "mse": 0.020257320255041122
+ },
+ {
+ "epoch": 202,
+ "loss": 0.4604725241661072,
+ "accuracy": 0.86326664686203,
+ "mse": 0.020205389708280563
+ },
+ {
+ "epoch": 203,
+ "loss": 0.4594633877277374,
+ "accuracy": 0.8630499839782715,
+ "mse": 0.020164256915450096
+ },
+ {
+ "epoch": 204,
+ "loss": 0.4593481421470642,
+ "accuracy": 0.8636999726295471,
+ "mse": 0.020103352144360542
+ },
+ {
+ "epoch": 205,
+ "loss": 0.458232045173645,
+ "accuracy": 0.8646000027656555,
+ "mse": 0.020080696791410446
+ },
+ {
+ "epoch": 206,
+ "loss": 0.4560525417327881,
+ "accuracy": 0.8646166920661926,
+ "mse": 0.019984638318419456
+ },
+ {
+ "epoch": 207,
+ "loss": 0.4560525417327881,
+ "accuracy": 0.8646166920661926,
+ "mse": 0.019984638318419456
+ },
+ {
+ "epoch": 208,
+ "loss": 0.4552159607410431,
+ "accuracy": 0.8640833497047424,
+ "mse": 0.02000802382826805
+ },
+ {
+ "epoch": 209,
+ "loss": 0.45459914207458496,
+ "accuracy": 0.8650500178337097,
+ "mse": 0.01992463693022728
+ },
+ {
+ "epoch": 210,
+ "loss": 0.45373666286468506,
+ "accuracy": 0.8642833232879639,
+ "mse": 0.01994975656270981
+ },
+ {
+ "epoch": 211,
+ "loss": 0.452452152967453,
+ "accuracy": 0.864983320236206,
+ "mse": 0.019845983013510704
+ },
+ {
+ "epoch": 212,
+ "loss": 0.45222243666648865,
+ "accuracy": 0.8653500080108643,
+ "mse": 0.01984952948987484
+ },
+ {
+ "epoch": 213,
+ "loss": 0.451869398355484,
+ "accuracy": 0.8656499981880188,
+ "mse": 0.019843172281980515
+ },
+ {
+ "epoch": 214,
+ "loss": 0.4509514570236206,
+ "accuracy": 0.8651833534240723,
+ "mse": 0.019874941557645798
+ },
+ {
+ "epoch": 215,
+ "loss": 0.45046576857566833,
+ "accuracy": 0.8652333617210388,
+ "mse": 0.01983705535531044
+ },
+ {
+ "epoch": 216,
+ "loss": 0.4504336714744568,
+ "accuracy": 0.8656666874885559,
+ "mse": 0.01989103853702545
+ },
+ {
+ "epoch": 217,
+ "loss": 0.4495491683483124,
+ "accuracy": 0.865933358669281,
+ "mse": 0.0198066383600235
+ },
+ {
+ "epoch": 218,
+ "loss": 0.4487816393375397,
+ "accuracy": 0.8651999831199646,
+ "mse": 0.0198209248483181
+ },
+ {
+ "epoch": 219,
+ "loss": 0.44763457775115967,
+ "accuracy": 0.8654833436012268,
+ "mse": 0.01975177973508835
+ },
+ {
+ "epoch": 220,
+ "loss": 0.4459497630596161,
+ "accuracy": 0.8664166927337646,
+ "mse": 0.0197211392223835
+ },
+ {
+ "epoch": 221,
+ "loss": 0.4459497630596161,
+ "accuracy": 0.8664166927337646,
+ "mse": 0.0197211392223835
+ },
+ {
+ "epoch": 222,
+ "loss": 0.4448271095752716,
+ "accuracy": 0.8665833473205566,
+ "mse": 0.019647160544991493
+ },
+ {
+ "epoch": 223,
+ "loss": 0.44436711072921753,
+ "accuracy": 0.8675833344459534,
+ "mse": 0.019559169188141823
+ },
+ {
+ "epoch": 224,
+ "loss": 0.44436711072921753,
+ "accuracy": 0.8675833344459534,
+ "mse": 0.019559169188141823
+ },
+ {
+ "epoch": 225,
+ "loss": 0.4432216286659241,
+ "accuracy": 0.8683833479881287,
+ "mse": 0.019489340484142303
+ },
+ {
+ "epoch": 226,
+ "loss": 0.4431568384170532,
+ "accuracy": 0.8683000206947327,
+ "mse": 0.019508030265569687
+ },
+ {
+ "epoch": 227,
+ "loss": 0.442644327878952,
+ "accuracy": 0.8690333366394043,
+ "mse": 0.01944315992295742
+ },
+ {
+ "epoch": 228,
+ "loss": 0.441727876663208,
+ "accuracy": 0.8690166473388672,
+ "mse": 0.01942053623497486
+ },
+ {
+ "epoch": 229,
+ "loss": 0.44139915704727173,
+ "accuracy": 0.8687666654586792,
+ "mse": 0.019426867365837097
+ },
+ {
+ "epoch": 230,
+ "loss": 0.44036629796028137,
+ "accuracy": 0.869350016117096,
+ "mse": 0.01937939040362835
+ },
+ {
+ "epoch": 231,
+ "loss": 0.44007858633995056,
+ "accuracy": 0.8688666820526123,
+ "mse": 0.01937006786465645
+ },
+ {
+ "epoch": 232,
+ "loss": 0.43969473242759705,
+ "accuracy": 0.8693166375160217,
+ "mse": 0.019341377541422844
+ },
+ {
+ "epoch": 233,
+ "loss": 0.43857541680336,
+ "accuracy": 0.8691333532333374,
+ "mse": 0.01927792653441429
+ },
+ {
+ "epoch": 234,
+ "loss": 0.4380344748497009,
+ "accuracy": 0.8701500296592712,
+ "mse": 0.019258635118603706
+ },
+ {
+ "epoch": 235,
+ "loss": 0.4380130171775818,
+ "accuracy": 0.870116651058197,
+ "mse": 0.01926390267908573
+ },
+ {
+ "epoch": 236,
+ "loss": 0.4369747042655945,
+ "accuracy": 0.8706166744232178,
+ "mse": 0.019244614988565445
+ },
+ {
+ "epoch": 237,
+ "loss": 0.4368351697921753,
+ "accuracy": 0.8711166381835938,
+ "mse": 0.01922871358692646
+ },
+ {
+ "epoch": 238,
+ "loss": 0.4359946548938751,
+ "accuracy": 0.8708500266075134,
+ "mse": 0.019248489290475845
+ },
+ {
+ "epoch": 239,
+ "loss": 0.43546172976493835,
+ "accuracy": 0.8715833425521851,
+ "mse": 0.019210752099752426
+ },
+ {
+ "epoch": 240,
+ "loss": 0.4350419342517853,
+ "accuracy": 0.871566653251648,
+ "mse": 0.01916772872209549
+ }
+ ]
+ },
+ {
+ "seed": 73,
+ "model_fingerprint": "2e6c351372592f10",
+ "fit_time_sec": 33.0256,
+ "improvement_count": 237,
+ "last_improvement_epoch": 240,
+ "checkpoints": [
+ {
+ "epoch": 20,
+ "train_loss": 1.703110694885254,
+ "train_acc": 0.4322333335876465,
+ "train_mse": 0.07236693799495697,
+ "test_loss": 1.662993311882019,
+ "test_acc": 0.4422999918460846,
+ "test_mse": 0.07139508426189423
+ },
+ {
+ "epoch": 40,
+ "train_loss": 1.234723448753357,
+ "train_acc": 0.605400025844574,
+ "train_mse": 0.05369972065091133,
+ "test_loss": 1.2019942998886108,
+ "test_acc": 0.6128000020980835,
+ "test_mse": 0.05271701514720917
+ },
+ {
+ "epoch": 60,
+ "train_loss": 0.9583781361579895,
+ "train_acc": 0.7071499824523926,
+ "train_mse": 0.04126281663775444,
+ "test_loss": 0.9148314595222473,
+ "test_acc": 0.7215999960899353,
+ "test_mse": 0.03978179767727852
+ },
+ {
+ "epoch": 80,
+ "train_loss": 0.781466543674469,
+ "train_acc": 0.7578666806221008,
+ "train_mse": 0.034513432532548904,
+ "test_loss": 0.7499686479568481,
+ "test_acc": 0.7670999765396118,
+ "test_mse": 0.03327890485525131
+ },
+ {
+ "epoch": 100,
+ "train_loss": 0.6772935390472412,
+ "train_acc": 0.7944999933242798,
+ "train_mse": 0.029873577877879143,
+ "test_loss": 0.6402292251586914,
+ "test_acc": 0.8046000003814697,
+ "test_mse": 0.02839311771094799
+ },
+ {
+ "epoch": 120,
+ "train_loss": 0.6110365986824036,
+ "train_acc": 0.8133666515350342,
+ "train_mse": 0.027105839923024178,
+ "test_loss": 0.5728253722190857,
+ "test_acc": 0.821399986743927,
+ "test_mse": 0.02574964240193367
+ },
+ {
+ "epoch": 140,
+ "train_loss": 0.5631463527679443,
+ "train_acc": 0.8302500247955322,
+ "train_mse": 0.024875810369849205,
+ "test_loss": 0.5334057807922363,
+ "test_acc": 0.8353999853134155,
+ "test_mse": 0.023713810369372368
+ },
+ {
+ "epoch": 160,
+ "train_loss": 0.5311679840087891,
+ "train_acc": 0.8410833477973938,
+ "train_mse": 0.023450637236237526,
+ "test_loss": 0.501768171787262,
+ "test_acc": 0.8464000225067139,
+ "test_mse": 0.022286171093583107
+ },
+ {
+ "epoch": 180,
+ "train_loss": 0.5000290870666504,
+ "train_acc": 0.8493833541870117,
+ "train_mse": 0.022157883271574974,
+ "test_loss": 0.4740225672721863,
+ "test_acc": 0.8550000190734863,
+ "test_mse": 0.021153515204787254
+ },
+ {
+ "epoch": 200,
+ "train_loss": 0.48113930225372314,
+ "train_acc": 0.8564833402633667,
+ "train_mse": 0.02121545933187008,
+ "test_loss": 0.4526425898075104,
+ "test_acc": 0.8634999990463257,
+ "test_mse": 0.020089736208319664
+ },
+ {
+ "epoch": 220,
+ "train_loss": 0.46380415558815,
+ "train_acc": 0.8618666529655457,
+ "train_mse": 0.020463503897190094,
+ "test_loss": 0.4359147846698761,
+ "test_acc": 0.8684999942779541,
+ "test_mse": 0.019339669495821
+ },
+ {
+ "epoch": 240,
+ "train_loss": 0.449687123298645,
+ "train_acc": 0.8664166927337646,
+ "train_mse": 0.019846484065055847,
+ "test_loss": 0.4234127998352051,
+ "test_acc": 0.8718000054359436,
+ "test_mse": 0.018784264102578163
+ }
+ ],
+ "completed": true,
+ "error": null,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "epoch_history": [
+ {
+ "epoch": 1,
+ "loss": 2.414574146270752,
+ "accuracy": 0.13204999268054962,
+ "mse": 0.09269577264785767
+ },
+ {
+ "epoch": 2,
+ "loss": 2.4086410999298096,
+ "accuracy": 0.141483336687088,
+ "mse": 0.09242582321166992
+ },
+ {
+ "epoch": 3,
+ "loss": 2.363835096359253,
+ "accuracy": 0.1467166692018509,
+ "mse": 0.09184609353542328
+ },
+ {
+ "epoch": 4,
+ "loss": 2.3283281326293945,
+ "accuracy": 0.16816666722297668,
+ "mse": 0.09098929911851883
+ },
+ {
+ "epoch": 5,
+ "loss": 2.291069269180298,
+ "accuracy": 0.203616663813591,
+ "mse": 0.08995424211025238
+ },
+ {
+ "epoch": 6,
+ "loss": 2.2262332439422607,
+ "accuracy": 0.23285000026226044,
+ "mse": 0.08825325220823288
+ },
+ {
+ "epoch": 7,
+ "loss": 2.20208740234375,
+ "accuracy": 0.2498166710138321,
+ "mse": 0.08740948140621185
+ },
+ {
+ "epoch": 8,
+ "loss": 2.1513030529022217,
+ "accuracy": 0.26460000872612,
+ "mse": 0.08588720858097076
+ },
+ {
+ "epoch": 9,
+ "loss": 2.130186080932617,
+ "accuracy": 0.2775000035762787,
+ "mse": 0.08550321310758591
+ },
+ {
+ "epoch": 10,
+ "loss": 2.0828537940979004,
+ "accuracy": 0.2813166677951813,
+ "mse": 0.08468858152627945
+ },
+ {
+ "epoch": 11,
+ "loss": 2.0315990447998047,
+ "accuracy": 0.29766666889190674,
+ "mse": 0.08364257961511612
+ },
+ {
+ "epoch": 12,
+ "loss": 1.9701182842254639,
+ "accuracy": 0.3124000132083893,
+ "mse": 0.08143104612827301
+ },
+ {
+ "epoch": 13,
+ "loss": 1.928099513053894,
+ "accuracy": 0.32519999146461487,
+ "mse": 0.0805482417345047
+ },
+ {
+ "epoch": 14,
+ "loss": 1.8766974210739136,
+ "accuracy": 0.3473333418369293,
+ "mse": 0.07878895103931427
+ },
+ {
+ "epoch": 15,
+ "loss": 1.8432810306549072,
+ "accuracy": 0.35405001044273376,
+ "mse": 0.07818205654621124
+ },
+ {
+ "epoch": 16,
+ "loss": 1.8184367418289185,
+ "accuracy": 0.3601999878883362,
+ "mse": 0.07771221548318863
+ },
+ {
+ "epoch": 17,
+ "loss": 1.7921768426895142,
+ "accuracy": 0.38075000047683716,
+ "mse": 0.07665841281414032
+ },
+ {
+ "epoch": 18,
+ "loss": 1.7434711456298828,
+ "accuracy": 0.39446666836738586,
+ "mse": 0.0751606673002243
+ },
+ {
+ "epoch": 19,
+ "loss": 1.7207882404327393,
+ "accuracy": 0.4059999883174896,
+ "mse": 0.07451806962490082
+ },
+ {
+ "epoch": 20,
+ "loss": 1.703110694885254,
+ "accuracy": 0.4322333335876465,
+ "mse": 0.07236693799495697
+ },
+ {
+ "epoch": 21,
+ "loss": 1.6656062602996826,
+ "accuracy": 0.4309333264827728,
+ "mse": 0.07185985147953033
+ },
+ {
+ "epoch": 22,
+ "loss": 1.640377163887024,
+ "accuracy": 0.4397333264350891,
+ "mse": 0.07128003984689713
+ },
+ {
+ "epoch": 23,
+ "loss": 1.602551817893982,
+ "accuracy": 0.45473334193229675,
+ "mse": 0.06954824179410934
+ },
+ {
+ "epoch": 24,
+ "loss": 1.5583189725875854,
+ "accuracy": 0.46851667761802673,
+ "mse": 0.06847219914197922
+ },
+ {
+ "epoch": 25,
+ "loss": 1.5273237228393555,
+ "accuracy": 0.47714999318122864,
+ "mse": 0.06707556545734406
+ },
+ {
+ "epoch": 26,
+ "loss": 1.4936084747314453,
+ "accuracy": 0.49558332562446594,
+ "mse": 0.0658927708864212
+ },
+ {
+ "epoch": 27,
+ "loss": 1.4567371606826782,
+ "accuracy": 0.5133000016212463,
+ "mse": 0.06419163197278976
+ },
+ {
+ "epoch": 28,
+ "loss": 1.4349539279937744,
+ "accuracy": 0.5220166444778442,
+ "mse": 0.06317440420389175
+ },
+ {
+ "epoch": 29,
+ "loss": 1.4205996990203857,
+ "accuracy": 0.5326666831970215,
+ "mse": 0.0624447800219059
+ },
+ {
+ "epoch": 30,
+ "loss": 1.396343469619751,
+ "accuracy": 0.5478333234786987,
+ "mse": 0.06086358800530434
+ },
+ {
+ "epoch": 31,
+ "loss": 1.3833963871002197,
+ "accuracy": 0.5451666712760925,
+ "mse": 0.06073316931724548
+ },
+ {
+ "epoch": 32,
+ "loss": 1.366824746131897,
+ "accuracy": 0.5521500110626221,
+ "mse": 0.06004268303513527
+ },
+ {
+ "epoch": 33,
+ "loss": 1.3498015403747559,
+ "accuracy": 0.5596666932106018,
+ "mse": 0.0591292530298233
+ },
+ {
+ "epoch": 34,
+ "loss": 1.3407446146011353,
+ "accuracy": 0.5618666410446167,
+ "mse": 0.05862642079591751
+ },
+ {
+ "epoch": 35,
+ "loss": 1.3232721090316772,
+ "accuracy": 0.5700833201408386,
+ "mse": 0.05792893096804619
+ },
+ {
+ "epoch": 36,
+ "loss": 1.3018308877944946,
+ "accuracy": 0.5779333114624023,
+ "mse": 0.056805454194545746
+ },
+ {
+ "epoch": 37,
+ "loss": 1.2803646326065063,
+ "accuracy": 0.588699996471405,
+ "mse": 0.055742762982845306
+ },
+ {
+ "epoch": 38,
+ "loss": 1.268272042274475,
+ "accuracy": 0.5956000089645386,
+ "mse": 0.05504179000854492
+ },
+ {
+ "epoch": 39,
+ "loss": 1.2466093301773071,
+ "accuracy": 0.6033333539962769,
+ "mse": 0.05403747782111168
+ },
+ {
+ "epoch": 40,
+ "loss": 1.234723448753357,
+ "accuracy": 0.605400025844574,
+ "mse": 0.05369972065091133
+ },
+ {
+ "epoch": 41,
+ "loss": 1.2187047004699707,
+ "accuracy": 0.6098666787147522,
+ "mse": 0.052995480597019196
+ },
+ {
+ "epoch": 42,
+ "loss": 1.207017421722412,
+ "accuracy": 0.615933358669281,
+ "mse": 0.05246154963970184
+ },
+ {
+ "epoch": 43,
+ "loss": 1.1948403120040894,
+ "accuracy": 0.6165666580200195,
+ "mse": 0.05217888951301575
+ },
+ {
+ "epoch": 44,
+ "loss": 1.1810132265090942,
+ "accuracy": 0.620983362197876,
+ "mse": 0.05178996920585632
+ },
+ {
+ "epoch": 45,
+ "loss": 1.168336033821106,
+ "accuracy": 0.6212833523750305,
+ "mse": 0.05145636573433876
+ },
+ {
+ "epoch": 46,
+ "loss": 1.131334662437439,
+ "accuracy": 0.6379166841506958,
+ "mse": 0.04959197714924812
+ },
+ {
+ "epoch": 47,
+ "loss": 1.1163318157196045,
+ "accuracy": 0.6446166634559631,
+ "mse": 0.04886316508054733
+ },
+ {
+ "epoch": 48,
+ "loss": 1.1114810705184937,
+ "accuracy": 0.6452666521072388,
+ "mse": 0.04888089373707771
+ },
+ {
+ "epoch": 49,
+ "loss": 1.0898659229278564,
+ "accuracy": 0.6551166772842407,
+ "mse": 0.0476401187479496
+ },
+ {
+ "epoch": 50,
+ "loss": 1.0820255279541016,
+ "accuracy": 0.660183310508728,
+ "mse": 0.047002293169498444
+ },
+ {
+ "epoch": 51,
+ "loss": 1.0644936561584473,
+ "accuracy": 0.6658999919891357,
+ "mse": 0.0463184230029583
+ },
+ {
+ "epoch": 52,
+ "loss": 1.0584444999694824,
+ "accuracy": 0.6722999811172485,
+ "mse": 0.04573918133974075
+ },
+ {
+ "epoch": 53,
+ "loss": 1.0524156093597412,
+ "accuracy": 0.6740166544914246,
+ "mse": 0.045501966029405594
+ },
+ {
+ "epoch": 54,
+ "loss": 1.0484199523925781,
+ "accuracy": 0.674833357334137,
+ "mse": 0.045208632946014404
+ },
+ {
+ "epoch": 55,
+ "loss": 1.03437077999115,
+ "accuracy": 0.6771500110626221,
+ "mse": 0.04503229260444641
+ },
+ {
+ "epoch": 56,
+ "loss": 1.023512840270996,
+ "accuracy": 0.6856833100318909,
+ "mse": 0.044141363352537155
+ },
+ {
+ "epoch": 57,
+ "loss": 1.00637948513031,
+ "accuracy": 0.6900500059127808,
+ "mse": 0.04355236887931824
+ },
+ {
+ "epoch": 58,
+ "loss": 0.9912204146385193,
+ "accuracy": 0.6955833435058594,
+ "mse": 0.04268778860569
+ },
+ {
+ "epoch": 59,
+ "loss": 0.9837228059768677,
+ "accuracy": 0.6990333199501038,
+ "mse": 0.042437102645635605
+ },
+ {
+ "epoch": 60,
+ "loss": 0.9583781361579895,
+ "accuracy": 0.7071499824523926,
+ "mse": 0.04126281663775444
+ },
+ {
+ "epoch": 61,
+ "loss": 0.9352142214775085,
+ "accuracy": 0.7147499918937683,
+ "mse": 0.040028516203165054
+ },
+ {
+ "epoch": 62,
+ "loss": 0.9340695738792419,
+ "accuracy": 0.7158166766166687,
+ "mse": 0.03995691239833832
+ },
+ {
+ "epoch": 63,
+ "loss": 0.930392861366272,
+ "accuracy": 0.716533362865448,
+ "mse": 0.0399252213537693
+ },
+ {
+ "epoch": 64,
+ "loss": 0.9176633954048157,
+ "accuracy": 0.7227500081062317,
+ "mse": 0.03916604444384575
+ },
+ {
+ "epoch": 65,
+ "loss": 0.9105371832847595,
+ "accuracy": 0.724399983882904,
+ "mse": 0.03887329250574112
+ },
+ {
+ "epoch": 66,
+ "loss": 0.8963521718978882,
+ "accuracy": 0.7271166443824768,
+ "mse": 0.03860384598374367
+ },
+ {
+ "epoch": 67,
+ "loss": 0.8884021043777466,
+ "accuracy": 0.728683352470398,
+ "mse": 0.0381564199924469
+ },
+ {
+ "epoch": 68,
+ "loss": 0.8758040070533752,
+ "accuracy": 0.7317666411399841,
+ "mse": 0.037940070033073425
+ },
+ {
+ "epoch": 69,
+ "loss": 0.860588014125824,
+ "accuracy": 0.7341166734695435,
+ "mse": 0.037413015961647034
+ },
+ {
+ "epoch": 70,
+ "loss": 0.8567206263542175,
+ "accuracy": 0.7351166605949402,
+ "mse": 0.037409327924251556
+ },
+ {
+ "epoch": 71,
+ "loss": 0.8496319055557251,
+ "accuracy": 0.7372000217437744,
+ "mse": 0.03707830235362053
+ },
+ {
+ "epoch": 72,
+ "loss": 0.839394748210907,
+ "accuracy": 0.7403500080108643,
+ "mse": 0.03666998818516731
+ },
+ {
+ "epoch": 73,
+ "loss": 0.8326200246810913,
+ "accuracy": 0.7438166737556458,
+ "mse": 0.036313436925411224
+ },
+ {
+ "epoch": 74,
+ "loss": 0.8240531086921692,
+ "accuracy": 0.7449333071708679,
+ "mse": 0.03600670397281647
+ },
+ {
+ "epoch": 75,
+ "loss": 0.8185017108917236,
+ "accuracy": 0.7480999827384949,
+ "mse": 0.03574215993285179
+ },
+ {
+ "epoch": 76,
+ "loss": 0.8120248913764954,
+ "accuracy": 0.7476833462715149,
+ "mse": 0.03558772802352905
+ },
+ {
+ "epoch": 77,
+ "loss": 0.8003321886062622,
+ "accuracy": 0.7540333271026611,
+ "mse": 0.03503324091434479
+ },
+ {
+ "epoch": 78,
+ "loss": 0.7947137951850891,
+ "accuracy": 0.7556833624839783,
+ "mse": 0.034928809851408005
+ },
+ {
+ "epoch": 79,
+ "loss": 0.7853738069534302,
+ "accuracy": 0.7587833404541016,
+ "mse": 0.034493155777454376
+ },
+ {
+ "epoch": 80,
+ "loss": 0.781466543674469,
+ "accuracy": 0.7578666806221008,
+ "mse": 0.034513432532548904
+ },
+ {
+ "epoch": 81,
+ "loss": 0.7727760672569275,
+ "accuracy": 0.7643666863441467,
+ "mse": 0.03388603776693344
+ },
+ {
+ "epoch": 82,
+ "loss": 0.7680574059486389,
+ "accuracy": 0.7648833394050598,
+ "mse": 0.03359862416982651
+ },
+ {
+ "epoch": 83,
+ "loss": 0.762535572052002,
+ "accuracy": 0.7684500217437744,
+ "mse": 0.03320125490427017
+ },
+ {
+ "epoch": 84,
+ "loss": 0.7474846243858337,
+ "accuracy": 0.7725666761398315,
+ "mse": 0.032589640468358994
+ },
+ {
+ "epoch": 85,
+ "loss": 0.7455113530158997,
+ "accuracy": 0.7736666798591614,
+ "mse": 0.032540395855903625
+ },
+ {
+ "epoch": 86,
+ "loss": 0.7337794303894043,
+ "accuracy": 0.7778499722480774,
+ "mse": 0.03193478658795357
+ },
+ {
+ "epoch": 87,
+ "loss": 0.7251227498054504,
+ "accuracy": 0.7788000106811523,
+ "mse": 0.03165125474333763
+ },
+ {
+ "epoch": 88,
+ "loss": 0.718483567237854,
+ "accuracy": 0.7817833423614502,
+ "mse": 0.031402837485075
+ },
+ {
+ "epoch": 89,
+ "loss": 0.7159523367881775,
+ "accuracy": 0.7807333469390869,
+ "mse": 0.03143352270126343
+ },
+ {
+ "epoch": 90,
+ "loss": 0.710383415222168,
+ "accuracy": 0.7826166749000549,
+ "mse": 0.031265903264284134
+ },
+ {
+ "epoch": 91,
+ "loss": 0.7052772045135498,
+ "accuracy": 0.7833166718482971,
+ "mse": 0.031189821660518646
+ },
+ {
+ "epoch": 92,
+ "loss": 0.7019606828689575,
+ "accuracy": 0.7846333384513855,
+ "mse": 0.031064342707395554
+ },
+ {
+ "epoch": 93,
+ "loss": 0.6998864412307739,
+ "accuracy": 0.7847999930381775,
+ "mse": 0.03106488287448883
+ },
+ {
+ "epoch": 94,
+ "loss": 0.6970031261444092,
+ "accuracy": 0.7861999869346619,
+ "mse": 0.030850792303681374
+ },
+ {
+ "epoch": 95,
+ "loss": 0.6922543048858643,
+ "accuracy": 0.7876499891281128,
+ "mse": 0.0306241475045681
+ },
+ {
+ "epoch": 96,
+ "loss": 0.6895252466201782,
+ "accuracy": 0.7896666526794434,
+ "mse": 0.030427388846874237
+ },
+ {
+ "epoch": 97,
+ "loss": 0.6875640749931335,
+ "accuracy": 0.7902166843414307,
+ "mse": 0.030271464958786964
+ },
+ {
+ "epoch": 98,
+ "loss": 0.6837601661682129,
+ "accuracy": 0.7907333374023438,
+ "mse": 0.03019705042243004
+ },
+ {
+ "epoch": 99,
+ "loss": 0.6802726984024048,
+ "accuracy": 0.7911666631698608,
+ "mse": 0.030022021383047104
+ },
+ {
+ "epoch": 100,
+ "loss": 0.6772935390472412,
+ "accuracy": 0.7944999933242798,
+ "mse": 0.029873577877879143
+ },
+ {
+ "epoch": 101,
+ "loss": 0.6741686463356018,
+ "accuracy": 0.793749988079071,
+ "mse": 0.029796868562698364
+ },
+ {
+ "epoch": 102,
+ "loss": 0.6717954277992249,
+ "accuracy": 0.7940000295639038,
+ "mse": 0.029739804565906525
+ },
+ {
+ "epoch": 103,
+ "loss": 0.6669585704803467,
+ "accuracy": 0.7975999712944031,
+ "mse": 0.029404625296592712
+ },
+ {
+ "epoch": 104,
+ "loss": 0.6596651673316956,
+ "accuracy": 0.7992833256721497,
+ "mse": 0.029143402352929115
+ },
+ {
+ "epoch": 105,
+ "loss": 0.6592240929603577,
+ "accuracy": 0.7987666726112366,
+ "mse": 0.029149316251277924
+ },
+ {
+ "epoch": 106,
+ "loss": 0.657468318939209,
+ "accuracy": 0.799049973487854,
+ "mse": 0.029105527326464653
+ },
+ {
+ "epoch": 107,
+ "loss": 0.6553120017051697,
+ "accuracy": 0.7996666431427002,
+ "mse": 0.028965000063180923
+ },
+ {
+ "epoch": 108,
+ "loss": 0.649477481842041,
+ "accuracy": 0.8011166453361511,
+ "mse": 0.028735818341374397
+ },
+ {
+ "epoch": 109,
+ "loss": 0.6483716368675232,
+ "accuracy": 0.8037333488464355,
+ "mse": 0.028530599549412727
+ },
+ {
+ "epoch": 110,
+ "loss": 0.6431794166564941,
+ "accuracy": 0.8040000200271606,
+ "mse": 0.02839997410774231
+ },
+ {
+ "epoch": 111,
+ "loss": 0.6396983861923218,
+ "accuracy": 0.8048999905586243,
+ "mse": 0.028284339234232903
+ },
+ {
+ "epoch": 112,
+ "loss": 0.6353538632392883,
+ "accuracy": 0.807200014591217,
+ "mse": 0.028062792494893074
+ },
+ {
+ "epoch": 113,
+ "loss": 0.6327446699142456,
+ "accuracy": 0.807116687297821,
+ "mse": 0.027912965044379234
+ },
+ {
+ "epoch": 114,
+ "loss": 0.6284050941467285,
+ "accuracy": 0.8085500001907349,
+ "mse": 0.027824843302369118
+ },
+ {
+ "epoch": 115,
+ "loss": 0.6268152594566345,
+ "accuracy": 0.8093500137329102,
+ "mse": 0.027707891538739204
+ },
+ {
+ "epoch": 116,
+ "loss": 0.6243881583213806,
+ "accuracy": 0.8099166750907898,
+ "mse": 0.02763967402279377
+ },
+ {
+ "epoch": 117,
+ "loss": 0.6222176551818848,
+ "accuracy": 0.8098999857902527,
+ "mse": 0.027570560574531555
+ },
+ {
+ "epoch": 118,
+ "loss": 0.6193534731864929,
+ "accuracy": 0.8109833598136902,
+ "mse": 0.027407048270106316
+ },
+ {
+ "epoch": 119,
+ "loss": 0.6121435761451721,
+ "accuracy": 0.8129000067710876,
+ "mse": 0.027141908183693886
+ },
+ {
+ "epoch": 120,
+ "loss": 0.6110365986824036,
+ "accuracy": 0.8133666515350342,
+ "mse": 0.027105839923024178
+ },
+ {
+ "epoch": 121,
+ "loss": 0.607293426990509,
+ "accuracy": 0.8153666853904724,
+ "mse": 0.026896169409155846
+ },
+ {
+ "epoch": 122,
+ "loss": 0.6072826385498047,
+ "accuracy": 0.8145666718482971,
+ "mse": 0.026919055730104446
+ },
+ {
+ "epoch": 123,
+ "loss": 0.6058600544929504,
+ "accuracy": 0.8154833316802979,
+ "mse": 0.02685522474348545
+ },
+ {
+ "epoch": 124,
+ "loss": 0.6029885411262512,
+ "accuracy": 0.8178166747093201,
+ "mse": 0.02666405588388443
+ },
+ {
+ "epoch": 125,
+ "loss": 0.596304178237915,
+ "accuracy": 0.8192166686058044,
+ "mse": 0.0263478085398674
+ },
+ {
+ "epoch": 126,
+ "loss": 0.5947750806808472,
+ "accuracy": 0.8204333186149597,
+ "mse": 0.026291493326425552
+ },
+ {
+ "epoch": 127,
+ "loss": 0.5946099162101746,
+ "accuracy": 0.821566641330719,
+ "mse": 0.026214612647891045
+ },
+ {
+ "epoch": 128,
+ "loss": 0.5919549465179443,
+ "accuracy": 0.8210833072662354,
+ "mse": 0.026114733889698982
+ },
+ {
+ "epoch": 129,
+ "loss": 0.588538646697998,
+ "accuracy": 0.8216666579246521,
+ "mse": 0.02602967619895935
+ },
+ {
+ "epoch": 130,
+ "loss": 0.5853483080863953,
+ "accuracy": 0.8215333223342896,
+ "mse": 0.02591628208756447
+ },
+ {
+ "epoch": 131,
+ "loss": 0.5853483080863953,
+ "accuracy": 0.8215333223342896,
+ "mse": 0.02591628208756447
+ },
+ {
+ "epoch": 132,
+ "loss": 0.5848174095153809,
+ "accuracy": 0.819433331489563,
+ "mse": 0.02596266195178032
+ },
+ {
+ "epoch": 133,
+ "loss": 0.5813794732093811,
+ "accuracy": 0.8223833441734314,
+ "mse": 0.0257836002856493
+ },
+ {
+ "epoch": 134,
+ "loss": 0.5786432027816772,
+ "accuracy": 0.8234999775886536,
+ "mse": 0.02558390237390995
+ },
+ {
+ "epoch": 135,
+ "loss": 0.5766130089759827,
+ "accuracy": 0.8237166404724121,
+ "mse": 0.02556212805211544
+ },
+ {
+ "epoch": 136,
+ "loss": 0.5724963545799255,
+ "accuracy": 0.8262333273887634,
+ "mse": 0.02532770112156868
+ },
+ {
+ "epoch": 137,
+ "loss": 0.570061206817627,
+ "accuracy": 0.8270666599273682,
+ "mse": 0.02523242123425007
+ },
+ {
+ "epoch": 138,
+ "loss": 0.5689972043037415,
+ "accuracy": 0.8274666666984558,
+ "mse": 0.025206029415130615
+ },
+ {
+ "epoch": 139,
+ "loss": 0.565800130367279,
+ "accuracy": 0.8279500007629395,
+ "mse": 0.025017164647579193
+ },
+ {
+ "epoch": 140,
+ "loss": 0.5631463527679443,
+ "accuracy": 0.8302500247955322,
+ "mse": 0.024875810369849205
+ },
+ {
+ "epoch": 141,
+ "loss": 0.5607755780220032,
+ "accuracy": 0.8300166726112366,
+ "mse": 0.024780642241239548
+ },
+ {
+ "epoch": 142,
+ "loss": 0.5606104135513306,
+ "accuracy": 0.8301833271980286,
+ "mse": 0.024745823815464973
+ },
+ {
+ "epoch": 143,
+ "loss": 0.5595632195472717,
+ "accuracy": 0.8311499953269958,
+ "mse": 0.024653596803545952
+ },
+ {
+ "epoch": 144,
+ "loss": 0.5581526160240173,
+ "accuracy": 0.832099974155426,
+ "mse": 0.024614963680505753
+ },
+ {
+ "epoch": 145,
+ "loss": 0.5561463832855225,
+ "accuracy": 0.8328666687011719,
+ "mse": 0.02452557533979416
+ },
+ {
+ "epoch": 146,
+ "loss": 0.5536938905715942,
+ "accuracy": 0.8347499966621399,
+ "mse": 0.024360042065382004
+ },
+ {
+ "epoch": 147,
+ "loss": 0.5526377558708191,
+ "accuracy": 0.8341166377067566,
+ "mse": 0.024316975846886635
+ },
+ {
+ "epoch": 148,
+ "loss": 0.5510162711143494,
+ "accuracy": 0.8354666829109192,
+ "mse": 0.024257643148303032
+ },
+ {
+ "epoch": 149,
+ "loss": 0.5495046377182007,
+ "accuracy": 0.8358500003814697,
+ "mse": 0.02416827157139778
+ },
+ {
+ "epoch": 150,
+ "loss": 0.5468350052833557,
+ "accuracy": 0.8361833095550537,
+ "mse": 0.024069709703326225
+ },
+ {
+ "epoch": 151,
+ "loss": 0.5449582934379578,
+ "accuracy": 0.8357499837875366,
+ "mse": 0.02400941029191017
+ },
+ {
+ "epoch": 152,
+ "loss": 0.543927788734436,
+ "accuracy": 0.8364499807357788,
+ "mse": 0.023983940482139587
+ },
+ {
+ "epoch": 153,
+ "loss": 0.542649507522583,
+ "accuracy": 0.8364499807357788,
+ "mse": 0.023942334577441216
+ },
+ {
+ "epoch": 154,
+ "loss": 0.5419157147407532,
+ "accuracy": 0.8360666632652283,
+ "mse": 0.02393990568816662
+ },
+ {
+ "epoch": 155,
+ "loss": 0.540157675743103,
+ "accuracy": 0.8361999988555908,
+ "mse": 0.023889055475592613
+ },
+ {
+ "epoch": 156,
+ "loss": 0.5386499762535095,
+ "accuracy": 0.8377000093460083,
+ "mse": 0.023815549910068512
+ },
+ {
+ "epoch": 157,
+ "loss": 0.5373024344444275,
+ "accuracy": 0.8374833464622498,
+ "mse": 0.023780427873134613
+ },
+ {
+ "epoch": 158,
+ "loss": 0.5352810621261597,
+ "accuracy": 0.8391166925430298,
+ "mse": 0.02361784689128399
+ },
+ {
+ "epoch": 159,
+ "loss": 0.5330520272254944,
+ "accuracy": 0.8398333191871643,
+ "mse": 0.02352483756840229
+ },
+ {
+ "epoch": 160,
+ "loss": 0.5311679840087891,
+ "accuracy": 0.8410833477973938,
+ "mse": 0.023450637236237526
+ },
+ {
+ "epoch": 161,
+ "loss": 0.5299530625343323,
+ "accuracy": 0.8414499759674072,
+ "mse": 0.023384707048535347
+ },
+ {
+ "epoch": 162,
+ "loss": 0.5275143980979919,
+ "accuracy": 0.8406999707221985,
+ "mse": 0.023340361192822456
+ },
+ {
+ "epoch": 163,
+ "loss": 0.5260158777236938,
+ "accuracy": 0.8410500288009644,
+ "mse": 0.0233036819845438
+ },
+ {
+ "epoch": 164,
+ "loss": 0.5248306393623352,
+ "accuracy": 0.840833306312561,
+ "mse": 0.023271819576621056
+ },
+ {
+ "epoch": 165,
+ "loss": 0.5229296088218689,
+ "accuracy": 0.8420166373252869,
+ "mse": 0.023163525387644768
+ },
+ {
+ "epoch": 166,
+ "loss": 0.5218507647514343,
+ "accuracy": 0.8410666584968567,
+ "mse": 0.023162871599197388
+ },
+ {
+ "epoch": 167,
+ "loss": 0.519870400428772,
+ "accuracy": 0.842283308506012,
+ "mse": 0.023074911907315254
+ },
+ {
+ "epoch": 168,
+ "loss": 0.5173833966255188,
+ "accuracy": 0.8428166508674622,
+ "mse": 0.022966573014855385
+ },
+ {
+ "epoch": 169,
+ "loss": 0.5155658721923828,
+ "accuracy": 0.8437333106994629,
+ "mse": 0.022893378511071205
+ },
+ {
+ "epoch": 170,
+ "loss": 0.5143352746963501,
+ "accuracy": 0.8442166447639465,
+ "mse": 0.022836871445178986
+ },
+ {
+ "epoch": 171,
+ "loss": 0.5130977630615234,
+ "accuracy": 0.8459333181381226,
+ "mse": 0.02271832711994648
+ },
+ {
+ "epoch": 172,
+ "loss": 0.511986494064331,
+ "accuracy": 0.8457000255584717,
+ "mse": 0.02269294299185276
+ },
+ {
+ "epoch": 173,
+ "loss": 0.509595513343811,
+ "accuracy": 0.8457666635513306,
+ "mse": 0.022661365568637848
+ },
+ {
+ "epoch": 174,
+ "loss": 0.5078558921813965,
+ "accuracy": 0.8460000157356262,
+ "mse": 0.022545836865901947
+ },
+ {
+ "epoch": 175,
+ "loss": 0.5064887404441833,
+ "accuracy": 0.8469499945640564,
+ "mse": 0.022514870390295982
+ },
+ {
+ "epoch": 176,
+ "loss": 0.5048143863677979,
+ "accuracy": 0.8473333120346069,
+ "mse": 0.022387105971574783
+ },
+ {
+ "epoch": 177,
+ "loss": 0.503877580165863,
+ "accuracy": 0.8466166853904724,
+ "mse": 0.022382790222764015
+ },
+ {
+ "epoch": 178,
+ "loss": 0.5028167366981506,
+ "accuracy": 0.8478999733924866,
+ "mse": 0.022313812747597694
+ },
+ {
+ "epoch": 179,
+ "loss": 0.5008286237716675,
+ "accuracy": 0.8488166928291321,
+ "mse": 0.02221272699534893
+ },
+ {
+ "epoch": 180,
+ "loss": 0.5000290870666504,
+ "accuracy": 0.8493833541870117,
+ "mse": 0.022157883271574974
+ },
+ {
+ "epoch": 181,
+ "loss": 0.4981861114501953,
+ "accuracy": 0.8505666851997375,
+ "mse": 0.022102084010839462
+ },
+ {
+ "epoch": 182,
+ "loss": 0.4963725805282593,
+ "accuracy": 0.8514166474342346,
+ "mse": 0.02194368466734886
+ },
+ {
+ "epoch": 183,
+ "loss": 0.4963725805282593,
+ "accuracy": 0.8514166474342346,
+ "mse": 0.02194368466734886
+ },
+ {
+ "epoch": 184,
+ "loss": 0.49606233835220337,
+ "accuracy": 0.8518000245094299,
+ "mse": 0.021929778158664703
+ },
+ {
+ "epoch": 185,
+ "loss": 0.4953683018684387,
+ "accuracy": 0.8515333533287048,
+ "mse": 0.02193184196949005
+ },
+ {
+ "epoch": 186,
+ "loss": 0.49217689037323,
+ "accuracy": 0.8539000153541565,
+ "mse": 0.021734334528446198
+ },
+ {
+ "epoch": 187,
+ "loss": 0.49185845255851746,
+ "accuracy": 0.8529333472251892,
+ "mse": 0.02174282632768154
+ },
+ {
+ "epoch": 188,
+ "loss": 0.49143049120903015,
+ "accuracy": 0.8535833358764648,
+ "mse": 0.02170458249747753
+ },
+ {
+ "epoch": 189,
+ "loss": 0.49022260308265686,
+ "accuracy": 0.8541499972343445,
+ "mse": 0.021626973524689674
+ },
+ {
+ "epoch": 190,
+ "loss": 0.48885780572891235,
+ "accuracy": 0.854449987411499,
+ "mse": 0.021585114300251007
+ },
+ {
+ "epoch": 191,
+ "loss": 0.4880245625972748,
+ "accuracy": 0.8545666933059692,
+ "mse": 0.02155035361647606
+ },
+ {
+ "epoch": 192,
+ "loss": 0.48710381984710693,
+ "accuracy": 0.8547166585922241,
+ "mse": 0.021520739421248436
+ },
+ {
+ "epoch": 193,
+ "loss": 0.4863168001174927,
+ "accuracy": 0.855400025844574,
+ "mse": 0.021460192278027534
+ },
+ {
+ "epoch": 194,
+ "loss": 0.48572155833244324,
+ "accuracy": 0.8553500175476074,
+ "mse": 0.021449964493513107
+ },
+ {
+ "epoch": 195,
+ "loss": 0.48470810055732727,
+ "accuracy": 0.8554166555404663,
+ "mse": 0.021394111216068268
+ },
+ {
+ "epoch": 196,
+ "loss": 0.48434212803840637,
+ "accuracy": 0.8556333184242249,
+ "mse": 0.021388808265328407
+ },
+ {
+ "epoch": 197,
+ "loss": 0.4832429587841034,
+ "accuracy": 0.855733335018158,
+ "mse": 0.021322699263691902
+ },
+ {
+ "epoch": 198,
+ "loss": 0.48277953267097473,
+ "accuracy": 0.8555166721343994,
+ "mse": 0.021286826580762863
+ },
+ {
+ "epoch": 199,
+ "loss": 0.48113930225372314,
+ "accuracy": 0.8564833402633667,
+ "mse": 0.02121545933187008
+ },
+ {
+ "epoch": 200,
+ "loss": 0.48113930225372314,
+ "accuracy": 0.8564833402633667,
+ "mse": 0.02121545933187008
+ },
+ {
+ "epoch": 201,
+ "loss": 0.4808978736400604,
+ "accuracy": 0.8564833402633667,
+ "mse": 0.021217580884695053
+ },
+ {
+ "epoch": 202,
+ "loss": 0.47957682609558105,
+ "accuracy": 0.8572666645050049,
+ "mse": 0.02115471102297306
+ },
+ {
+ "epoch": 203,
+ "loss": 0.47899970412254333,
+ "accuracy": 0.8563833236694336,
+ "mse": 0.02114832028746605
+ },
+ {
+ "epoch": 204,
+ "loss": 0.4782465100288391,
+ "accuracy": 0.8571333289146423,
+ "mse": 0.021089797839522362
+ },
+ {
+ "epoch": 205,
+ "loss": 0.47737908363342285,
+ "accuracy": 0.8575166463851929,
+ "mse": 0.021053865551948547
+ },
+ {
+ "epoch": 206,
+ "loss": 0.4760730266571045,
+ "accuracy": 0.8577333092689514,
+ "mse": 0.020957496017217636
+ },
+ {
+ "epoch": 207,
+ "loss": 0.47536709904670715,
+ "accuracy": 0.8582666516304016,
+ "mse": 0.020946867763996124
+ },
+ {
+ "epoch": 208,
+ "loss": 0.4732798933982849,
+ "accuracy": 0.8591166734695435,
+ "mse": 0.020853040739893913
+ },
+ {
+ "epoch": 209,
+ "loss": 0.4723389446735382,
+ "accuracy": 0.8585166931152344,
+ "mse": 0.020830469205975533
+ },
+ {
+ "epoch": 210,
+ "loss": 0.47112077474594116,
+ "accuracy": 0.8588333129882812,
+ "mse": 0.020800597965717316
+ },
+ {
+ "epoch": 211,
+ "loss": 0.470302551984787,
+ "accuracy": 0.8603000044822693,
+ "mse": 0.020735543221235275
+ },
+ {
+ "epoch": 212,
+ "loss": 0.46951183676719666,
+ "accuracy": 0.8604166507720947,
+ "mse": 0.020719358697533607
+ },
+ {
+ "epoch": 213,
+ "loss": 0.4686809778213501,
+ "accuracy": 0.8603500127792358,
+ "mse": 0.020685236901044846
+ },
+ {
+ "epoch": 214,
+ "loss": 0.46854764223098755,
+ "accuracy": 0.8598999977111816,
+ "mse": 0.020714063197374344
+ },
+ {
+ "epoch": 215,
+ "loss": 0.46765637397766113,
+ "accuracy": 0.8597999811172485,
+ "mse": 0.020686136558651924
+ },
+ {
+ "epoch": 216,
+ "loss": 0.46743249893188477,
+ "accuracy": 0.8599333167076111,
+ "mse": 0.020685069262981415
+ },
+ {
+ "epoch": 217,
+ "loss": 0.4665240943431854,
+ "accuracy": 0.8604000210762024,
+ "mse": 0.020638741552829742
+ },
+ {
+ "epoch": 218,
+ "loss": 0.46548548340797424,
+ "accuracy": 0.86121666431427,
+ "mse": 0.0205671563744545
+ },
+ {
+ "epoch": 219,
+ "loss": 0.4643442630767822,
+ "accuracy": 0.8614833354949951,
+ "mse": 0.020530832931399345
+ },
+ {
+ "epoch": 220,
+ "loss": 0.46380415558815,
+ "accuracy": 0.8618666529655457,
+ "mse": 0.020463503897190094
+ },
+ {
+ "epoch": 221,
+ "loss": 0.4632735550403595,
+ "accuracy": 0.8618833422660828,
+ "mse": 0.020439380779862404
+ },
+ {
+ "epoch": 222,
+ "loss": 0.46314218640327454,
+ "accuracy": 0.8619833588600159,
+ "mse": 0.02041696012020111
+ },
+ {
+ "epoch": 223,
+ "loss": 0.462208092212677,
+ "accuracy": 0.8625500202178955,
+ "mse": 0.02041381038725376
+ },
+ {
+ "epoch": 224,
+ "loss": 0.4611798822879791,
+ "accuracy": 0.8635166883468628,
+ "mse": 0.02032548002898693
+ },
+ {
+ "epoch": 225,
+ "loss": 0.4590543508529663,
+ "accuracy": 0.8633000254631042,
+ "mse": 0.02027859166264534
+ },
+ {
+ "epoch": 226,
+ "loss": 0.45901229977607727,
+ "accuracy": 0.8639833331108093,
+ "mse": 0.02025737799704075
+ },
+ {
+ "epoch": 227,
+ "loss": 0.4579267203807831,
+ "accuracy": 0.8636000156402588,
+ "mse": 0.020252693444490433
+ },
+ {
+ "epoch": 228,
+ "loss": 0.4578099548816681,
+ "accuracy": 0.8642666935920715,
+ "mse": 0.020203690975904465
+ },
+ {
+ "epoch": 229,
+ "loss": 0.4569973945617676,
+ "accuracy": 0.8647500276565552,
+ "mse": 0.020141836255788803
+ },
+ {
+ "epoch": 230,
+ "loss": 0.45676830410957336,
+ "accuracy": 0.8651166558265686,
+ "mse": 0.020131828263401985
+ },
+ {
+ "epoch": 231,
+ "loss": 0.45567914843559265,
+ "accuracy": 0.8652333617210388,
+ "mse": 0.02007649652659893
+ },
+ {
+ "epoch": 232,
+ "loss": 0.4552251398563385,
+ "accuracy": 0.8657666444778442,
+ "mse": 0.020051803439855576
+ },
+ {
+ "epoch": 233,
+ "loss": 0.45359694957733154,
+ "accuracy": 0.866683304309845,
+ "mse": 0.019991356879472733
+ },
+ {
+ "epoch": 234,
+ "loss": 0.4531172513961792,
+ "accuracy": 0.8659166693687439,
+ "mse": 0.019969915971159935
+ },
+ {
+ "epoch": 235,
+ "loss": 0.4524180293083191,
+ "accuracy": 0.8667333126068115,
+ "mse": 0.019950980320572853
+ },
+ {
+ "epoch": 236,
+ "loss": 0.4521808922290802,
+ "accuracy": 0.8668333292007446,
+ "mse": 0.019947310909628868
+ },
+ {
+ "epoch": 237,
+ "loss": 0.45130443572998047,
+ "accuracy": 0.8663666844367981,
+ "mse": 0.01991342194378376
+ },
+ {
+ "epoch": 238,
+ "loss": 0.450676828622818,
+ "accuracy": 0.8665666580200195,
+ "mse": 0.01989450864493847
+ },
+ {
+ "epoch": 239,
+ "loss": 0.4501597583293915,
+ "accuracy": 0.8670499920845032,
+ "mse": 0.019864557310938835
+ },
+ {
+ "epoch": 240,
+ "loss": 0.449687123298645,
+ "accuracy": 0.8664166927337646,
+ "mse": 0.019846484065055847
+ }
+ ]
+ },
+ {
+ "seed": 74,
+ "model_fingerprint": "4000fe3fb26ef207",
+ "fit_time_sec": 32.3565,
+ "improvement_count": 233,
+ "last_improvement_epoch": 240,
+ "checkpoints": [
+ {
+ "epoch": 20,
+ "train_loss": 1.696816325187683,
+ "train_acc": 0.4334833323955536,
+ "train_mse": 0.07303200662136078,
+ "test_loss": 1.685478925704956,
+ "test_acc": 0.4397999942302704,
+ "test_mse": 0.07274489104747772
+ },
+ {
+ "epoch": 40,
+ "train_loss": 1.2137997150421143,
+ "train_acc": 0.6062666773796082,
+ "train_mse": 0.053883783519268036,
+ "test_loss": 1.193790316581726,
+ "test_acc": 0.6158999800682068,
+ "test_mse": 0.05286615714430809
+ },
+ {
+ "epoch": 60,
+ "train_loss": 0.9459328651428223,
+ "train_acc": 0.7093166708946228,
+ "train_mse": 0.04073885455727577,
+ "test_loss": 0.926419734954834,
+ "test_acc": 0.7172999978065491,
+ "test_mse": 0.03994119539856911
+ },
+ {
+ "epoch": 80,
+ "train_loss": 0.7440351843833923,
+ "train_acc": 0.7731500267982483,
+ "train_mse": 0.03230465576052666,
+ "test_loss": 0.7158955335617065,
+ "test_acc": 0.7832000255584717,
+ "test_mse": 0.0311629269272089
+ },
+ {
+ "epoch": 100,
+ "train_loss": 0.6222507357597351,
+ "train_acc": 0.8106666803359985,
+ "train_mse": 0.02721019648015499,
+ "test_loss": 0.5782299041748047,
+ "test_acc": 0.826200008392334,
+ "test_mse": 0.025308359414339066
+ },
+ {
+ "epoch": 120,
+ "train_loss": 0.5712149143218994,
+ "train_acc": 0.8261666893959045,
+ "train_mse": 0.025098947808146477,
+ "test_loss": 0.5316479206085205,
+ "test_acc": 0.8402000069618225,
+ "test_mse": 0.023361243307590485
+ },
+ {
+ "epoch": 140,
+ "train_loss": 0.5278127193450928,
+ "train_acc": 0.8391500115394592,
+ "train_mse": 0.02332845889031887,
+ "test_loss": 0.5003852248191833,
+ "test_acc": 0.8485000133514404,
+ "test_mse": 0.022033091634511948
+ },
+ {
+ "epoch": 160,
+ "train_loss": 0.4974406957626343,
+ "train_acc": 0.8500166535377502,
+ "train_mse": 0.02210366539657116,
+ "test_loss": 0.4702143669128418,
+ "test_acc": 0.8614000082015991,
+ "test_mse": 0.02081647887825966
+ },
+ {
+ "epoch": 180,
+ "train_loss": 0.4760556221008301,
+ "train_acc": 0.8567833304405212,
+ "train_mse": 0.0210970938205719,
+ "test_loss": 0.4514496922492981,
+ "test_acc": 0.8648999929428101,
+ "test_mse": 0.01998041942715645
+ },
+ {
+ "epoch": 200,
+ "train_loss": 0.4600929617881775,
+ "train_acc": 0.8631166815757751,
+ "train_mse": 0.020222675055265427,
+ "test_loss": 0.43229734897613525,
+ "test_acc": 0.8694999814033508,
+ "test_mse": 0.01901264674961567
+ },
+ {
+ "epoch": 220,
+ "train_loss": 0.44254931807518005,
+ "train_acc": 0.8678500056266785,
+ "train_mse": 0.019469955936074257,
+ "test_loss": 0.417081743478775,
+ "test_acc": 0.8754000067710876,
+ "test_mse": 0.018321329727768898
+ },
+ {
+ "epoch": 240,
+ "train_loss": 0.43052077293395996,
+ "train_acc": 0.8725666403770447,
+ "train_mse": 0.018974633887410164,
+ "test_loss": 0.40485620498657227,
+ "test_acc": 0.8798999786376953,
+ "test_mse": 0.01778729446232319
+ }
+ ],
+ "completed": true,
+ "error": null,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "epoch_history": [
+ {
+ "epoch": 1,
+ "loss": 2.3630239963531494,
+ "accuracy": 0.1527833342552185,
+ "mse": 0.09098036587238312
+ },
+ {
+ "epoch": 2,
+ "loss": 2.3037056922912598,
+ "accuracy": 0.16278333961963654,
+ "mse": 0.08990588039159775
+ },
+ {
+ "epoch": 3,
+ "loss": 2.2243945598602295,
+ "accuracy": 0.2122499942779541,
+ "mse": 0.08827207237482071
+ },
+ {
+ "epoch": 4,
+ "loss": 2.2055628299713135,
+ "accuracy": 0.20544999837875366,
+ "mse": 0.08832919597625732
+ },
+ {
+ "epoch": 5,
+ "loss": 2.1198058128356934,
+ "accuracy": 0.2663666605949402,
+ "mse": 0.08560868352651596
+ },
+ {
+ "epoch": 6,
+ "loss": 2.10312819480896,
+ "accuracy": 0.2543666660785675,
+ "mse": 0.08583298325538635
+ },
+ {
+ "epoch": 7,
+ "loss": 2.069697856903076,
+ "accuracy": 0.27755001187324524,
+ "mse": 0.08490578085184097
+ },
+ {
+ "epoch": 8,
+ "loss": 2.0478670597076416,
+ "accuracy": 0.3057166635990143,
+ "mse": 0.08401036262512207
+ },
+ {
+ "epoch": 9,
+ "loss": 2.0278191566467285,
+ "accuracy": 0.31638333201408386,
+ "mse": 0.08333960920572281
+ },
+ {
+ "epoch": 10,
+ "loss": 2.0219058990478516,
+ "accuracy": 0.3160833418369293,
+ "mse": 0.08303756266832352
+ },
+ {
+ "epoch": 11,
+ "loss": 1.9831174612045288,
+ "accuracy": 0.3347499966621399,
+ "mse": 0.08158915489912033
+ },
+ {
+ "epoch": 12,
+ "loss": 1.955796241760254,
+ "accuracy": 0.3518333435058594,
+ "mse": 0.08042661100625992
+ },
+ {
+ "epoch": 13,
+ "loss": 1.9152729511260986,
+ "accuracy": 0.36908334493637085,
+ "mse": 0.07942232489585876
+ },
+ {
+ "epoch": 14,
+ "loss": 1.872546672821045,
+ "accuracy": 0.37985000014305115,
+ "mse": 0.07813462615013123
+ },
+ {
+ "epoch": 15,
+ "loss": 1.8248801231384277,
+ "accuracy": 0.39118334650993347,
+ "mse": 0.07671519368886948
+ },
+ {
+ "epoch": 16,
+ "loss": 1.7819229364395142,
+ "accuracy": 0.4088500142097473,
+ "mse": 0.07523704320192337
+ },
+ {
+ "epoch": 17,
+ "loss": 1.7707443237304688,
+ "accuracy": 0.4191666543483734,
+ "mse": 0.07474902272224426
+ },
+ {
+ "epoch": 18,
+ "loss": 1.7394194602966309,
+ "accuracy": 0.42178332805633545,
+ "mse": 0.07408100366592407
+ },
+ {
+ "epoch": 19,
+ "loss": 1.7251865863800049,
+ "accuracy": 0.4307500123977661,
+ "mse": 0.07361482083797455
+ },
+ {
+ "epoch": 20,
+ "loss": 1.696816325187683,
+ "accuracy": 0.4334833323955536,
+ "mse": 0.07303200662136078
+ },
+ {
+ "epoch": 21,
+ "loss": 1.6524786949157715,
+ "accuracy": 0.4505833387374878,
+ "mse": 0.07184039056301117
+ },
+ {
+ "epoch": 22,
+ "loss": 1.635809302330017,
+ "accuracy": 0.45350000262260437,
+ "mse": 0.07129822671413422
+ },
+ {
+ "epoch": 23,
+ "loss": 1.5947659015655518,
+ "accuracy": 0.462883323431015,
+ "mse": 0.07008268684148788
+ },
+ {
+ "epoch": 24,
+ "loss": 1.57978093624115,
+ "accuracy": 0.47278332710266113,
+ "mse": 0.06934765726327896
+ },
+ {
+ "epoch": 25,
+ "loss": 1.5446536540985107,
+ "accuracy": 0.4747166633605957,
+ "mse": 0.06858624517917633
+ },
+ {
+ "epoch": 26,
+ "loss": 1.5205860137939453,
+ "accuracy": 0.48820000886917114,
+ "mse": 0.06731872260570526
+ },
+ {
+ "epoch": 27,
+ "loss": 1.4893425703048706,
+ "accuracy": 0.4993000030517578,
+ "mse": 0.06618457287549973
+ },
+ {
+ "epoch": 28,
+ "loss": 1.4588110446929932,
+ "accuracy": 0.5132166743278503,
+ "mse": 0.06471127271652222
+ },
+ {
+ "epoch": 29,
+ "loss": 1.432752251625061,
+ "accuracy": 0.5204333066940308,
+ "mse": 0.06394749134778976
+ },
+ {
+ "epoch": 30,
+ "loss": 1.421046257019043,
+ "accuracy": 0.5311833620071411,
+ "mse": 0.0629466101527214
+ },
+ {
+ "epoch": 31,
+ "loss": 1.38520085811615,
+ "accuracy": 0.5421666502952576,
+ "mse": 0.06176381558179855
+ },
+ {
+ "epoch": 32,
+ "loss": 1.3660283088684082,
+ "accuracy": 0.5495499968528748,
+ "mse": 0.06077636778354645
+ },
+ {
+ "epoch": 33,
+ "loss": 1.3414093255996704,
+ "accuracy": 0.5612333416938782,
+ "mse": 0.059384364634752274
+ },
+ {
+ "epoch": 34,
+ "loss": 1.322603702545166,
+ "accuracy": 0.5676500201225281,
+ "mse": 0.058645155280828476
+ },
+ {
+ "epoch": 35,
+ "loss": 1.3152570724487305,
+ "accuracy": 0.5706666707992554,
+ "mse": 0.058264557272195816
+ },
+ {
+ "epoch": 36,
+ "loss": 1.295859694480896,
+ "accuracy": 0.5825166702270508,
+ "mse": 0.0572269968688488
+ },
+ {
+ "epoch": 37,
+ "loss": 1.284435510635376,
+ "accuracy": 0.5828333497047424,
+ "mse": 0.05695948004722595
+ },
+ {
+ "epoch": 38,
+ "loss": 1.2508333921432495,
+ "accuracy": 0.5966833233833313,
+ "mse": 0.055514685809612274
+ },
+ {
+ "epoch": 39,
+ "loss": 1.231177568435669,
+ "accuracy": 0.5995500087738037,
+ "mse": 0.054748717695474625
+ },
+ {
+ "epoch": 40,
+ "loss": 1.2137997150421143,
+ "accuracy": 0.6062666773796082,
+ "mse": 0.053883783519268036
+ },
+ {
+ "epoch": 41,
+ "loss": 1.194353461265564,
+ "accuracy": 0.6142500042915344,
+ "mse": 0.05318419262766838
+ },
+ {
+ "epoch": 42,
+ "loss": 1.174881935119629,
+ "accuracy": 0.6201000213623047,
+ "mse": 0.05209552124142647
+ },
+ {
+ "epoch": 43,
+ "loss": 1.1521174907684326,
+ "accuracy": 0.6325666904449463,
+ "mse": 0.05099694803357124
+ },
+ {
+ "epoch": 44,
+ "loss": 1.1367510557174683,
+ "accuracy": 0.6382499933242798,
+ "mse": 0.05012534558773041
+ },
+ {
+ "epoch": 45,
+ "loss": 1.124802589416504,
+ "accuracy": 0.6426666378974915,
+ "mse": 0.049558740109205246
+ },
+ {
+ "epoch": 46,
+ "loss": 1.112693190574646,
+ "accuracy": 0.6499999761581421,
+ "mse": 0.048659827560186386
+ },
+ {
+ "epoch": 47,
+ "loss": 1.1040773391723633,
+ "accuracy": 0.651199996471405,
+ "mse": 0.048423610627651215
+ },
+ {
+ "epoch": 48,
+ "loss": 1.0888868570327759,
+ "accuracy": 0.6572333574295044,
+ "mse": 0.04771972820162773
+ },
+ {
+ "epoch": 49,
+ "loss": 1.0764598846435547,
+ "accuracy": 0.6634666919708252,
+ "mse": 0.04710058867931366
+ },
+ {
+ "epoch": 50,
+ "loss": 1.0673680305480957,
+ "accuracy": 0.6664666533470154,
+ "mse": 0.04666503518819809
+ },
+ {
+ "epoch": 51,
+ "loss": 1.0543677806854248,
+ "accuracy": 0.670283317565918,
+ "mse": 0.045965809375047684
+ },
+ {
+ "epoch": 52,
+ "loss": 1.0384453535079956,
+ "accuracy": 0.6765833497047424,
+ "mse": 0.04518212378025055
+ },
+ {
+ "epoch": 53,
+ "loss": 1.0212924480438232,
+ "accuracy": 0.6823833584785461,
+ "mse": 0.044266778975725174
+ },
+ {
+ "epoch": 54,
+ "loss": 1.018552541732788,
+ "accuracy": 0.6852999925613403,
+ "mse": 0.04419276863336563
+ },
+ {
+ "epoch": 55,
+ "loss": 1.0011581182479858,
+ "accuracy": 0.6913999915122986,
+ "mse": 0.043259259313344955
+ },
+ {
+ "epoch": 56,
+ "loss": 0.9913690090179443,
+ "accuracy": 0.6966833472251892,
+ "mse": 0.04286181926727295
+ },
+ {
+ "epoch": 57,
+ "loss": 0.9797490239143372,
+ "accuracy": 0.6992499828338623,
+ "mse": 0.04218696430325508
+ },
+ {
+ "epoch": 58,
+ "loss": 0.9708109498023987,
+ "accuracy": 0.7006499767303467,
+ "mse": 0.04195536673069
+ },
+ {
+ "epoch": 59,
+ "loss": 0.9581699967384338,
+ "accuracy": 0.7047333121299744,
+ "mse": 0.041498079895973206
+ },
+ {
+ "epoch": 60,
+ "loss": 0.9459328651428223,
+ "accuracy": 0.7093166708946228,
+ "mse": 0.04073885455727577
+ },
+ {
+ "epoch": 61,
+ "loss": 0.9272240400314331,
+ "accuracy": 0.7155666947364807,
+ "mse": 0.04002755880355835
+ },
+ {
+ "epoch": 62,
+ "loss": 0.9196280241012573,
+ "accuracy": 0.7164666652679443,
+ "mse": 0.03979748114943504
+ },
+ {
+ "epoch": 63,
+ "loss": 0.9002792239189148,
+ "accuracy": 0.7237499952316284,
+ "mse": 0.03872166574001312
+ },
+ {
+ "epoch": 64,
+ "loss": 0.8878228664398193,
+ "accuracy": 0.7301333546638489,
+ "mse": 0.038066647946834564
+ },
+ {
+ "epoch": 65,
+ "loss": 0.8766346573829651,
+ "accuracy": 0.7316166758537292,
+ "mse": 0.03782809153199196
+ },
+ {
+ "epoch": 66,
+ "loss": 0.8653509020805359,
+ "accuracy": 0.7366999983787537,
+ "mse": 0.03708691895008087
+ },
+ {
+ "epoch": 67,
+ "loss": 0.8536397218704224,
+ "accuracy": 0.7369999885559082,
+ "mse": 0.03685572370886803
+ },
+ {
+ "epoch": 68,
+ "loss": 0.8463982939720154,
+ "accuracy": 0.7384833097457886,
+ "mse": 0.036677755415439606
+ },
+ {
+ "epoch": 69,
+ "loss": 0.837080717086792,
+ "accuracy": 0.7424666881561279,
+ "mse": 0.03625546395778656
+ },
+ {
+ "epoch": 70,
+ "loss": 0.8337094187736511,
+ "accuracy": 0.7432833313941956,
+ "mse": 0.03614634647965431
+ },
+ {
+ "epoch": 71,
+ "loss": 0.8217216730117798,
+ "accuracy": 0.7453166842460632,
+ "mse": 0.03572219982743263
+ },
+ {
+ "epoch": 72,
+ "loss": 0.8141146302223206,
+ "accuracy": 0.7521666884422302,
+ "mse": 0.03512018546462059
+ },
+ {
+ "epoch": 73,
+ "loss": 0.7970340847969055,
+ "accuracy": 0.7565333247184753,
+ "mse": 0.03447367623448372
+ },
+ {
+ "epoch": 74,
+ "loss": 0.7864437699317932,
+ "accuracy": 0.7613666653633118,
+ "mse": 0.033970560878515244
+ },
+ {
+ "epoch": 75,
+ "loss": 0.7779678106307983,
+ "accuracy": 0.762066662311554,
+ "mse": 0.03375285491347313
+ },
+ {
+ "epoch": 76,
+ "loss": 0.767817497253418,
+ "accuracy": 0.7669500112533569,
+ "mse": 0.03327062353491783
+ },
+ {
+ "epoch": 77,
+ "loss": 0.7549446821212769,
+ "accuracy": 0.771133303642273,
+ "mse": 0.03271302953362465
+ },
+ {
+ "epoch": 78,
+ "loss": 0.7462713122367859,
+ "accuracy": 0.7739333510398865,
+ "mse": 0.032391492277383804
+ },
+ {
+ "epoch": 79,
+ "loss": 0.7462713122367859,
+ "accuracy": 0.7739333510398865,
+ "mse": 0.032391492277383804
+ },
+ {
+ "epoch": 80,
+ "loss": 0.7440351843833923,
+ "accuracy": 0.7731500267982483,
+ "mse": 0.03230465576052666
+ },
+ {
+ "epoch": 81,
+ "loss": 0.7333055734634399,
+ "accuracy": 0.7772666811943054,
+ "mse": 0.03187013790011406
+ },
+ {
+ "epoch": 82,
+ "loss": 0.7307215332984924,
+ "accuracy": 0.7773500084877014,
+ "mse": 0.03179104998707771
+ },
+ {
+ "epoch": 83,
+ "loss": 0.7255259156227112,
+ "accuracy": 0.7803166508674622,
+ "mse": 0.03150658309459686
+ },
+ {
+ "epoch": 84,
+ "loss": 0.7210279703140259,
+ "accuracy": 0.7813000082969666,
+ "mse": 0.03135791793465614
+ },
+ {
+ "epoch": 85,
+ "loss": 0.7156904935836792,
+ "accuracy": 0.7824833393096924,
+ "mse": 0.031099990010261536
+ },
+ {
+ "epoch": 86,
+ "loss": 0.7078953981399536,
+ "accuracy": 0.7849666476249695,
+ "mse": 0.030828086659312248
+ },
+ {
+ "epoch": 87,
+ "loss": 0.70184725522995,
+ "accuracy": 0.7866500020027161,
+ "mse": 0.030538564547896385
+ },
+ {
+ "epoch": 88,
+ "loss": 0.6958460807800293,
+ "accuracy": 0.7879166603088379,
+ "mse": 0.03035806305706501
+ },
+ {
+ "epoch": 89,
+ "loss": 0.6876054406166077,
+ "accuracy": 0.7907666563987732,
+ "mse": 0.029966900125145912
+ },
+ {
+ "epoch": 90,
+ "loss": 0.6844158172607422,
+ "accuracy": 0.7928333282470703,
+ "mse": 0.02972610667347908
+ },
+ {
+ "epoch": 91,
+ "loss": 0.6737735867500305,
+ "accuracy": 0.7958166599273682,
+ "mse": 0.029323160648345947
+ },
+ {
+ "epoch": 92,
+ "loss": 0.673694372177124,
+ "accuracy": 0.7954000234603882,
+ "mse": 0.029240882024168968
+ },
+ {
+ "epoch": 93,
+ "loss": 0.6624342203140259,
+ "accuracy": 0.7990333437919617,
+ "mse": 0.028790690004825592
+ },
+ {
+ "epoch": 94,
+ "loss": 0.6568635702133179,
+ "accuracy": 0.8008833527565002,
+ "mse": 0.02863914705812931
+ },
+ {
+ "epoch": 95,
+ "loss": 0.6462782621383667,
+ "accuracy": 0.803600013256073,
+ "mse": 0.028178853914141655
+ },
+ {
+ "epoch": 96,
+ "loss": 0.6360609531402588,
+ "accuracy": 0.8065166473388672,
+ "mse": 0.027844371274113655
+ },
+ {
+ "epoch": 97,
+ "loss": 0.6326407790184021,
+ "accuracy": 0.8080833554267883,
+ "mse": 0.02759004943072796
+ },
+ {
+ "epoch": 98,
+ "loss": 0.6306620836257935,
+ "accuracy": 0.808733344078064,
+ "mse": 0.02752634696662426
+ },
+ {
+ "epoch": 99,
+ "loss": 0.6271352767944336,
+ "accuracy": 0.8093666434288025,
+ "mse": 0.027393857017159462
+ },
+ {
+ "epoch": 100,
+ "loss": 0.6222507357597351,
+ "accuracy": 0.8106666803359985,
+ "mse": 0.02721019648015499
+ },
+ {
+ "epoch": 101,
+ "loss": 0.6222507357597351,
+ "accuracy": 0.8106666803359985,
+ "mse": 0.02721019648015499
+ },
+ {
+ "epoch": 102,
+ "loss": 0.619790256023407,
+ "accuracy": 0.8120833039283752,
+ "mse": 0.027113283053040504
+ },
+ {
+ "epoch": 103,
+ "loss": 0.618463933467865,
+ "accuracy": 0.8115333318710327,
+ "mse": 0.027071474120020866
+ },
+ {
+ "epoch": 104,
+ "loss": 0.6133121848106384,
+ "accuracy": 0.8127999901771545,
+ "mse": 0.026906926184892654
+ },
+ {
+ "epoch": 105,
+ "loss": 0.6107783317565918,
+ "accuracy": 0.8129333257675171,
+ "mse": 0.026872603222727776
+ },
+ {
+ "epoch": 106,
+ "loss": 0.6082960367202759,
+ "accuracy": 0.8148999810218811,
+ "mse": 0.026674076914787292
+ },
+ {
+ "epoch": 107,
+ "loss": 0.6009210348129272,
+ "accuracy": 0.817883312702179,
+ "mse": 0.02633483149111271
+ },
+ {
+ "epoch": 108,
+ "loss": 0.5988345742225647,
+ "accuracy": 0.8194666504859924,
+ "mse": 0.02614101953804493
+ },
+ {
+ "epoch": 109,
+ "loss": 0.5938186049461365,
+ "accuracy": 0.8198500275611877,
+ "mse": 0.025903373956680298
+ },
+ {
+ "epoch": 110,
+ "loss": 0.5930478572845459,
+ "accuracy": 0.8211666941642761,
+ "mse": 0.025866981595754623
+ },
+ {
+ "epoch": 111,
+ "loss": 0.5906341671943665,
+ "accuracy": 0.8216666579246521,
+ "mse": 0.025814196094870567
+ },
+ {
+ "epoch": 112,
+ "loss": 0.5878962278366089,
+ "accuracy": 0.8225666880607605,
+ "mse": 0.02572830766439438
+ },
+ {
+ "epoch": 113,
+ "loss": 0.5850037336349487,
+ "accuracy": 0.8238333463668823,
+ "mse": 0.025641176849603653
+ },
+ {
+ "epoch": 114,
+ "loss": 0.582137405872345,
+ "accuracy": 0.8238999843597412,
+ "mse": 0.025492342188954353
+ },
+ {
+ "epoch": 115,
+ "loss": 0.5812022089958191,
+ "accuracy": 0.8229833245277405,
+ "mse": 0.025514476001262665
+ },
+ {
+ "epoch": 116,
+ "loss": 0.5803804397583008,
+ "accuracy": 0.8237333297729492,
+ "mse": 0.025522857904434204
+ },
+ {
+ "epoch": 117,
+ "loss": 0.5766667723655701,
+ "accuracy": 0.8241999745368958,
+ "mse": 0.025350471958518028
+ },
+ {
+ "epoch": 118,
+ "loss": 0.5751571655273438,
+ "accuracy": 0.8245499730110168,
+ "mse": 0.02532154694199562
+ },
+ {
+ "epoch": 119,
+ "loss": 0.5731304883956909,
+ "accuracy": 0.8257166743278503,
+ "mse": 0.02527613192796707
+ },
+ {
+ "epoch": 120,
+ "loss": 0.5712149143218994,
+ "accuracy": 0.8261666893959045,
+ "mse": 0.025098947808146477
+ },
+ {
+ "epoch": 121,
+ "loss": 0.5677908658981323,
+ "accuracy": 0.8260166645050049,
+ "mse": 0.025060269981622696
+ },
+ {
+ "epoch": 122,
+ "loss": 0.5656010508537292,
+ "accuracy": 0.8276500105857849,
+ "mse": 0.024995462968945503
+ },
+ {
+ "epoch": 123,
+ "loss": 0.5626923441886902,
+ "accuracy": 0.8275333046913147,
+ "mse": 0.02487090416252613
+ },
+ {
+ "epoch": 124,
+ "loss": 0.5613378882408142,
+ "accuracy": 0.8272333145141602,
+ "mse": 0.024908646941184998
+ },
+ {
+ "epoch": 125,
+ "loss": 0.5576561093330383,
+ "accuracy": 0.8288000226020813,
+ "mse": 0.024770718067884445
+ },
+ {
+ "epoch": 126,
+ "loss": 0.5560534000396729,
+ "accuracy": 0.8289166688919067,
+ "mse": 0.024700000882148743
+ },
+ {
+ "epoch": 127,
+ "loss": 0.5499910116195679,
+ "accuracy": 0.831849992275238,
+ "mse": 0.024372415617108345
+ },
+ {
+ "epoch": 128,
+ "loss": 0.5493881702423096,
+ "accuracy": 0.8321499824523926,
+ "mse": 0.02433355152606964
+ },
+ {
+ "epoch": 129,
+ "loss": 0.5473952889442444,
+ "accuracy": 0.833299994468689,
+ "mse": 0.024196293205022812
+ },
+ {
+ "epoch": 130,
+ "loss": 0.5458563566207886,
+ "accuracy": 0.8337833285331726,
+ "mse": 0.024104656651616096
+ },
+ {
+ "epoch": 131,
+ "loss": 0.5451492667198181,
+ "accuracy": 0.833383321762085,
+ "mse": 0.024106426164507866
+ },
+ {
+ "epoch": 132,
+ "loss": 0.5421653389930725,
+ "accuracy": 0.8348833322525024,
+ "mse": 0.024034947156906128
+ },
+ {
+ "epoch": 133,
+ "loss": 0.5407246947288513,
+ "accuracy": 0.8345833420753479,
+ "mse": 0.02397237904369831
+ },
+ {
+ "epoch": 134,
+ "loss": 0.538515031337738,
+ "accuracy": 0.8355833292007446,
+ "mse": 0.023901434615254402
+ },
+ {
+ "epoch": 135,
+ "loss": 0.5380927920341492,
+ "accuracy": 0.835433304309845,
+ "mse": 0.023862890899181366
+ },
+ {
+ "epoch": 136,
+ "loss": 0.5360697507858276,
+ "accuracy": 0.836733341217041,
+ "mse": 0.023723512887954712
+ },
+ {
+ "epoch": 137,
+ "loss": 0.5347724556922913,
+ "accuracy": 0.8378333449363708,
+ "mse": 0.02364363893866539
+ },
+ {
+ "epoch": 138,
+ "loss": 0.5312538146972656,
+ "accuracy": 0.8386666774749756,
+ "mse": 0.023494655266404152
+ },
+ {
+ "epoch": 139,
+ "loss": 0.5283239483833313,
+ "accuracy": 0.8393833041191101,
+ "mse": 0.023377012461423874
+ },
+ {
+ "epoch": 140,
+ "loss": 0.5278127193450928,
+ "accuracy": 0.8391500115394592,
+ "mse": 0.02332845889031887
+ },
+ {
+ "epoch": 141,
+ "loss": 0.5250416398048401,
+ "accuracy": 0.8405333161354065,
+ "mse": 0.023241570219397545
+ },
+ {
+ "epoch": 142,
+ "loss": 0.5234243869781494,
+ "accuracy": 0.8409500122070312,
+ "mse": 0.023135364055633545
+ },
+ {
+ "epoch": 143,
+ "loss": 0.5211421847343445,
+ "accuracy": 0.8431833386421204,
+ "mse": 0.02301214449107647
+ },
+ {
+ "epoch": 144,
+ "loss": 0.5187271237373352,
+ "accuracy": 0.8421000242233276,
+ "mse": 0.02299448847770691
+ },
+ {
+ "epoch": 145,
+ "loss": 0.5166958570480347,
+ "accuracy": 0.8441500067710876,
+ "mse": 0.022885238751769066
+ },
+ {
+ "epoch": 146,
+ "loss": 0.5163524150848389,
+ "accuracy": 0.8437333106994629,
+ "mse": 0.02291448600590229
+ },
+ {
+ "epoch": 147,
+ "loss": 0.515056312084198,
+ "accuracy": 0.8433499932289124,
+ "mse": 0.02289889007806778
+ },
+ {
+ "epoch": 148,
+ "loss": 0.5139864683151245,
+ "accuracy": 0.8443166613578796,
+ "mse": 0.02283903770148754
+ },
+ {
+ "epoch": 149,
+ "loss": 0.512658953666687,
+ "accuracy": 0.8444833159446716,
+ "mse": 0.022744812071323395
+ },
+ {
+ "epoch": 150,
+ "loss": 0.5121028423309326,
+ "accuracy": 0.8443333506584167,
+ "mse": 0.022763565182685852
+ },
+ {
+ "epoch": 151,
+ "loss": 0.51014244556427,
+ "accuracy": 0.8454333543777466,
+ "mse": 0.02266719751060009
+ },
+ {
+ "epoch": 152,
+ "loss": 0.5082402229309082,
+ "accuracy": 0.8468833565711975,
+ "mse": 0.022531718015670776
+ },
+ {
+ "epoch": 153,
+ "loss": 0.507989764213562,
+ "accuracy": 0.8462833166122437,
+ "mse": 0.02255597710609436
+ },
+ {
+ "epoch": 154,
+ "loss": 0.5056824088096619,
+ "accuracy": 0.8472166657447815,
+ "mse": 0.022462164983153343
+ },
+ {
+ "epoch": 155,
+ "loss": 0.5048742294311523,
+ "accuracy": 0.8472166657447815,
+ "mse": 0.022399263456463814
+ },
+ {
+ "epoch": 156,
+ "loss": 0.5033592581748962,
+ "accuracy": 0.8486166596412659,
+ "mse": 0.022310348227620125
+ },
+ {
+ "epoch": 157,
+ "loss": 0.5010842680931091,
+ "accuracy": 0.8497333526611328,
+ "mse": 0.02220926433801651
+ },
+ {
+ "epoch": 158,
+ "loss": 0.5000863671302795,
+ "accuracy": 0.8493333458900452,
+ "mse": 0.022213216871023178
+ },
+ {
+ "epoch": 159,
+ "loss": 0.49874627590179443,
+ "accuracy": 0.8495166897773743,
+ "mse": 0.022182581946253777
+ },
+ {
+ "epoch": 160,
+ "loss": 0.4974406957626343,
+ "accuracy": 0.8500166535377502,
+ "mse": 0.02210366539657116
+ },
+ {
+ "epoch": 161,
+ "loss": 0.4974406957626343,
+ "accuracy": 0.8500166535377502,
+ "mse": 0.02210366539657116
+ },
+ {
+ "epoch": 162,
+ "loss": 0.49674463272094727,
+ "accuracy": 0.8502833247184753,
+ "mse": 0.022116821259260178
+ },
+ {
+ "epoch": 163,
+ "loss": 0.4954787790775299,
+ "accuracy": 0.8502500057220459,
+ "mse": 0.022093413397669792
+ },
+ {
+ "epoch": 164,
+ "loss": 0.4942980706691742,
+ "accuracy": 0.8515166640281677,
+ "mse": 0.021973256021738052
+ },
+ {
+ "epoch": 165,
+ "loss": 0.4933535158634186,
+ "accuracy": 0.8511499762535095,
+ "mse": 0.02194303274154663
+ },
+ {
+ "epoch": 166,
+ "loss": 0.4921789765357971,
+ "accuracy": 0.8513500094413757,
+ "mse": 0.021908262744545937
+ },
+ {
+ "epoch": 167,
+ "loss": 0.4916118383407593,
+ "accuracy": 0.8521833419799805,
+ "mse": 0.021824130788445473
+ },
+ {
+ "epoch": 168,
+ "loss": 0.4905576705932617,
+ "accuracy": 0.8523666858673096,
+ "mse": 0.021799955517053604
+ },
+ {
+ "epoch": 169,
+ "loss": 0.4898163676261902,
+ "accuracy": 0.8517666459083557,
+ "mse": 0.021796097978949547
+ },
+ {
+ "epoch": 170,
+ "loss": 0.48833197355270386,
+ "accuracy": 0.8525166511535645,
+ "mse": 0.021750150248408318
+ },
+ {
+ "epoch": 171,
+ "loss": 0.48703789710998535,
+ "accuracy": 0.8529499769210815,
+ "mse": 0.021685900166630745
+ },
+ {
+ "epoch": 172,
+ "loss": 0.48582369089126587,
+ "accuracy": 0.8529999852180481,
+ "mse": 0.02162271738052368
+ },
+ {
+ "epoch": 173,
+ "loss": 0.48443207144737244,
+ "accuracy": 0.8543499708175659,
+ "mse": 0.021514860913157463
+ },
+ {
+ "epoch": 174,
+ "loss": 0.4828304052352905,
+ "accuracy": 0.8550000190734863,
+ "mse": 0.02140514738857746
+ },
+ {
+ "epoch": 175,
+ "loss": 0.4817134141921997,
+ "accuracy": 0.8551333546638489,
+ "mse": 0.021365880966186523
+ },
+ {
+ "epoch": 176,
+ "loss": 0.48087090253829956,
+ "accuracy": 0.8558499813079834,
+ "mse": 0.02126201055943966
+ },
+ {
+ "epoch": 177,
+ "loss": 0.47998613119125366,
+ "accuracy": 0.8557833433151245,
+ "mse": 0.02126311883330345
+ },
+ {
+ "epoch": 178,
+ "loss": 0.4783943295478821,
+ "accuracy": 0.8567500114440918,
+ "mse": 0.021159702911973
+ },
+ {
+ "epoch": 179,
+ "loss": 0.47793516516685486,
+ "accuracy": 0.8566333055496216,
+ "mse": 0.02115999348461628
+ },
+ {
+ "epoch": 180,
+ "loss": 0.4760556221008301,
+ "accuracy": 0.8567833304405212,
+ "mse": 0.0210970938205719
+ },
+ {
+ "epoch": 181,
+ "loss": 0.4760556221008301,
+ "accuracy": 0.8567833304405212,
+ "mse": 0.0210970938205719
+ },
+ {
+ "epoch": 182,
+ "loss": 0.47493013739585876,
+ "accuracy": 0.8579999804496765,
+ "mse": 0.02098955400288105
+ },
+ {
+ "epoch": 183,
+ "loss": 0.47420287132263184,
+ "accuracy": 0.8572999835014343,
+ "mse": 0.0209650918841362
+ },
+ {
+ "epoch": 184,
+ "loss": 0.4730876088142395,
+ "accuracy": 0.857699990272522,
+ "mse": 0.02089950442314148
+ },
+ {
+ "epoch": 185,
+ "loss": 0.4730876088142395,
+ "accuracy": 0.857699990272522,
+ "mse": 0.02089950442314148
+ },
+ {
+ "epoch": 186,
+ "loss": 0.4720984399318695,
+ "accuracy": 0.8586833477020264,
+ "mse": 0.020865244790911674
+ },
+ {
+ "epoch": 187,
+ "loss": 0.47146543860435486,
+ "accuracy": 0.8579833507537842,
+ "mse": 0.02089264616370201
+ },
+ {
+ "epoch": 188,
+ "loss": 0.47009482979774475,
+ "accuracy": 0.8597000241279602,
+ "mse": 0.02079925872385502
+ },
+ {
+ "epoch": 189,
+ "loss": 0.46936875581741333,
+ "accuracy": 0.8596833348274231,
+ "mse": 0.020767973735928535
+ },
+ {
+ "epoch": 190,
+ "loss": 0.46852096915245056,
+ "accuracy": 0.8593166470527649,
+ "mse": 0.020671848207712173
+ },
+ {
+ "epoch": 191,
+ "loss": 0.467838317155838,
+ "accuracy": 0.8607333302497864,
+ "mse": 0.020650144666433334
+ },
+ {
+ "epoch": 192,
+ "loss": 0.4668159484863281,
+ "accuracy": 0.8607666492462158,
+ "mse": 0.020587366074323654
+ },
+ {
+ "epoch": 193,
+ "loss": 0.466328501701355,
+ "accuracy": 0.8604833483695984,
+ "mse": 0.020583108067512512
+ },
+ {
+ "epoch": 194,
+ "loss": 0.4654600918292999,
+ "accuracy": 0.8600500226020813,
+ "mse": 0.020594771951436996
+ },
+ {
+ "epoch": 195,
+ "loss": 0.46456289291381836,
+ "accuracy": 0.8605333566665649,
+ "mse": 0.020523613318800926
+ },
+ {
+ "epoch": 196,
+ "loss": 0.46337783336639404,
+ "accuracy": 0.8616499900817871,
+ "mse": 0.020448744297027588
+ },
+ {
+ "epoch": 197,
+ "loss": 0.4629991948604584,
+ "accuracy": 0.8608333468437195,
+ "mse": 0.020443007349967957
+ },
+ {
+ "epoch": 198,
+ "loss": 0.46296426653862,
+ "accuracy": 0.8623499870300293,
+ "mse": 0.020393138751387596
+ },
+ {
+ "epoch": 199,
+ "loss": 0.46137571334838867,
+ "accuracy": 0.862933337688446,
+ "mse": 0.02029273845255375
+ },
+ {
+ "epoch": 200,
+ "loss": 0.4600929617881775,
+ "accuracy": 0.8631166815757751,
+ "mse": 0.020222675055265427
+ },
+ {
+ "epoch": 201,
+ "loss": 0.45938289165496826,
+ "accuracy": 0.8629000186920166,
+ "mse": 0.020218554884195328
+ },
+ {
+ "epoch": 202,
+ "loss": 0.4581224024295807,
+ "accuracy": 0.8635333180427551,
+ "mse": 0.0201848354190588
+ },
+ {
+ "epoch": 203,
+ "loss": 0.4573151171207428,
+ "accuracy": 0.8634666800498962,
+ "mse": 0.02015502192080021
+ },
+ {
+ "epoch": 204,
+ "loss": 0.4561801850795746,
+ "accuracy": 0.8637833595275879,
+ "mse": 0.020146451890468597
+ },
+ {
+ "epoch": 205,
+ "loss": 0.45509952306747437,
+ "accuracy": 0.8646000027656555,
+ "mse": 0.020065084099769592
+ },
+ {
+ "epoch": 206,
+ "loss": 0.4545951783657074,
+ "accuracy": 0.8646666407585144,
+ "mse": 0.020072542130947113
+ },
+ {
+ "epoch": 207,
+ "loss": 0.4529186189174652,
+ "accuracy": 0.8645333051681519,
+ "mse": 0.01999843679368496
+ },
+ {
+ "epoch": 208,
+ "loss": 0.4529186189174652,
+ "accuracy": 0.8645333051681519,
+ "mse": 0.01999843679368496
+ },
+ {
+ "epoch": 209,
+ "loss": 0.4526504576206207,
+ "accuracy": 0.8646666407585144,
+ "mse": 0.019998988136649132
+ },
+ {
+ "epoch": 210,
+ "loss": 0.45071613788604736,
+ "accuracy": 0.8652833104133606,
+ "mse": 0.0198847446590662
+ },
+ {
+ "epoch": 211,
+ "loss": 0.4502124488353729,
+ "accuracy": 0.8659666776657104,
+ "mse": 0.019833490252494812
+ },
+ {
+ "epoch": 212,
+ "loss": 0.4494096338748932,
+ "accuracy": 0.8666999936103821,
+ "mse": 0.019818613305687904
+ },
+ {
+ "epoch": 213,
+ "loss": 0.4477328062057495,
+ "accuracy": 0.8672333359718323,
+ "mse": 0.019723938778042793
+ },
+ {
+ "epoch": 214,
+ "loss": 0.44759514927864075,
+ "accuracy": 0.8667833209037781,
+ "mse": 0.019707363098859787
+ },
+ {
+ "epoch": 215,
+ "loss": 0.4469120502471924,
+ "accuracy": 0.8677999973297119,
+ "mse": 0.019625311717391014
+ },
+ {
+ "epoch": 216,
+ "loss": 0.4459882378578186,
+ "accuracy": 0.8675500154495239,
+ "mse": 0.019606946036219597
+ },
+ {
+ "epoch": 217,
+ "loss": 0.44550684094429016,
+ "accuracy": 0.8679166436195374,
+ "mse": 0.01959061063826084
+ },
+ {
+ "epoch": 218,
+ "loss": 0.44455528259277344,
+ "accuracy": 0.8676833510398865,
+ "mse": 0.019564863294363022
+ },
+ {
+ "epoch": 219,
+ "loss": 0.44352129101753235,
+ "accuracy": 0.868233323097229,
+ "mse": 0.019497763365507126
+ },
+ {
+ "epoch": 220,
+ "loss": 0.44254931807518005,
+ "accuracy": 0.8678500056266785,
+ "mse": 0.019469955936074257
+ },
+ {
+ "epoch": 221,
+ "loss": 0.4421125650405884,
+ "accuracy": 0.868483304977417,
+ "mse": 0.01946171186864376
+ },
+ {
+ "epoch": 222,
+ "loss": 0.44123560190200806,
+ "accuracy": 0.8688166737556458,
+ "mse": 0.019451148808002472
+ },
+ {
+ "epoch": 223,
+ "loss": 0.44057366251945496,
+ "accuracy": 0.8687833547592163,
+ "mse": 0.019426917657256126
+ },
+ {
+ "epoch": 224,
+ "loss": 0.439426451921463,
+ "accuracy": 0.8694999814033508,
+ "mse": 0.019352028146386147
+ },
+ {
+ "epoch": 225,
+ "loss": 0.43926140666007996,
+ "accuracy": 0.8688833117485046,
+ "mse": 0.01934938319027424
+ },
+ {
+ "epoch": 226,
+ "loss": 0.43890267610549927,
+ "accuracy": 0.8689333200454712,
+ "mse": 0.019329160451889038
+ },
+ {
+ "epoch": 227,
+ "loss": 0.4385967552661896,
+ "accuracy": 0.8694333434104919,
+ "mse": 0.01930309645831585
+ },
+ {
+ "epoch": 228,
+ "loss": 0.43804556131362915,
+ "accuracy": 0.8698166608810425,
+ "mse": 0.01925451122224331
+ },
+ {
+ "epoch": 229,
+ "loss": 0.43716660141944885,
+ "accuracy": 0.8698999881744385,
+ "mse": 0.019219394773244858
+ },
+ {
+ "epoch": 230,
+ "loss": 0.4363481104373932,
+ "accuracy": 0.8705499768257141,
+ "mse": 0.01917898841202259
+ },
+ {
+ "epoch": 231,
+ "loss": 0.4363481104373932,
+ "accuracy": 0.8705499768257141,
+ "mse": 0.01917898841202259
+ },
+ {
+ "epoch": 232,
+ "loss": 0.43512555956840515,
+ "accuracy": 0.8711000084877014,
+ "mse": 0.01912212185561657
+ },
+ {
+ "epoch": 233,
+ "loss": 0.4340628981590271,
+ "accuracy": 0.8714666962623596,
+ "mse": 0.019065313041210175
+ },
+ {
+ "epoch": 234,
+ "loss": 0.4337393641471863,
+ "accuracy": 0.8712166547775269,
+ "mse": 0.019062884151935577
+ },
+ {
+ "epoch": 235,
+ "loss": 0.43324196338653564,
+ "accuracy": 0.8713666796684265,
+ "mse": 0.019023772329092026
+ },
+ {
+ "epoch": 236,
+ "loss": 0.43261486291885376,
+ "accuracy": 0.8720999956130981,
+ "mse": 0.019012412056326866
+ },
+ {
+ "epoch": 237,
+ "loss": 0.43175020813941956,
+ "accuracy": 0.8720666766166687,
+ "mse": 0.01899314485490322
+ },
+ {
+ "epoch": 238,
+ "loss": 0.43119779229164124,
+ "accuracy": 0.8725333213806152,
+ "mse": 0.018995171412825584
+ },
+ {
+ "epoch": 239,
+ "loss": 0.4308997690677643,
+ "accuracy": 0.8728333115577698,
+ "mse": 0.018979579210281372
+ },
+ {
+ "epoch": 240,
+ "loss": 0.43052077293395996,
+ "accuracy": 0.8725666403770447,
+ "mse": 0.018974633887410164
+ }
+ ]
+ },
+ {
+ "seed": 75,
+ "model_fingerprint": "0966039f5ef7af88",
+ "fit_time_sec": 33.1184,
+ "improvement_count": 235,
+ "last_improvement_epoch": 240,
+ "checkpoints": [
+ {
+ "epoch": 20,
+ "train_loss": 1.7082723379135132,
+ "train_acc": 0.42640000581741333,
+ "train_mse": 0.07211916148662567,
+ "test_loss": 1.6778934001922607,
+ "test_acc": 0.43220001459121704,
+ "test_mse": 0.07167963683605194
+ },
+ {
+ "epoch": 40,
+ "train_loss": 1.2474853992462158,
+ "train_acc": 0.628333330154419,
+ "train_mse": 0.05103134736418724,
+ "test_loss": 1.1880637407302856,
+ "test_acc": 0.6402000188827515,
+ "test_mse": 0.04922466725111008
+ },
+ {
+ "epoch": 60,
+ "train_loss": 0.9827106595039368,
+ "train_acc": 0.7029333114624023,
+ "train_mse": 0.041922468692064285,
+ "test_loss": 0.9340476393699646,
+ "test_acc": 0.7074000239372253,
+ "test_mse": 0.040672920644283295
+ },
+ {
+ "epoch": 80,
+ "train_loss": 0.8061239719390869,
+ "train_acc": 0.7508833408355713,
+ "train_mse": 0.035569027066230774,
+ "test_loss": 0.7613834738731384,
+ "test_acc": 0.7562999725341797,
+ "test_mse": 0.03404615819454193
+ },
+ {
+ "epoch": 100,
+ "train_loss": 0.6677705645561218,
+ "train_acc": 0.7959833145141602,
+ "train_mse": 0.029427148401737213,
+ "test_loss": 0.6365524530410767,
+ "test_acc": 0.8015999794006348,
+ "test_mse": 0.027956314384937286
+ },
+ {
+ "epoch": 120,
+ "train_loss": 0.5898874998092651,
+ "train_acc": 0.8204500079154968,
+ "train_mse": 0.025896690785884857,
+ "test_loss": 0.5661898255348206,
+ "test_acc": 0.8285999894142151,
+ "test_mse": 0.024743687361478806
+ },
+ {
+ "epoch": 140,
+ "train_loss": 0.5386065244674683,
+ "train_acc": 0.8367666602134705,
+ "train_mse": 0.023783763870596886,
+ "test_loss": 0.5188254714012146,
+ "test_acc": 0.8396999835968018,
+ "test_mse": 0.022942783311009407
+ },
+ {
+ "epoch": 160,
+ "train_loss": 0.5006535053253174,
+ "train_acc": 0.8497833609580994,
+ "train_mse": 0.022141018882393837,
+ "test_loss": 0.48212501406669617,
+ "test_acc": 0.8569999933242798,
+ "test_mse": 0.021169248968362808
+ },
+ {
+ "epoch": 180,
+ "train_loss": 0.47602227330207825,
+ "train_acc": 0.8565999865531921,
+ "train_mse": 0.021099673584103584,
+ "test_loss": 0.45692178606987,
+ "test_acc": 0.861299991607666,
+ "test_mse": 0.020099563524127007
+ },
+ {
+ "epoch": 200,
+ "train_loss": 0.4532005488872528,
+ "train_acc": 0.8648999929428101,
+ "train_mse": 0.020130231976509094,
+ "test_loss": 0.4406105577945709,
+ "test_acc": 0.8676999807357788,
+ "test_mse": 0.019379951059818268
+ },
+ {
+ "epoch": 220,
+ "train_loss": 0.4393870532512665,
+ "train_acc": 0.8705000281333923,
+ "train_mse": 0.019430004060268402,
+ "test_loss": 0.42279207706451416,
+ "test_acc": 0.8766999840736389,
+ "test_mse": 0.018535815179347992
+ },
+ {
+ "epoch": 240,
+ "train_loss": 0.4296344220638275,
+ "train_acc": 0.8724499940872192,
+ "train_mse": 0.019024165347218513,
+ "test_loss": 0.40994536876678467,
+ "test_acc": 0.8802000284194946,
+ "test_mse": 0.01800552010536194
+ }
+ ],
+ "completed": true,
+ "error": null,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Full Dataset Evaluation",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "epoch_history": [
+ {
+ "epoch": 1,
+ "loss": 2.369859218597412,
+ "accuracy": 0.11746666580438614,
+ "mse": 0.09212285280227661
+ },
+ {
+ "epoch": 2,
+ "loss": 2.3162167072296143,
+ "accuracy": 0.16775000095367432,
+ "mse": 0.09060963988304138
+ },
+ {
+ "epoch": 3,
+ "loss": 2.2464652061462402,
+ "accuracy": 0.204066663980484,
+ "mse": 0.08891025930643082
+ },
+ {
+ "epoch": 4,
+ "loss": 2.1792819499969482,
+ "accuracy": 0.23203332722187042,
+ "mse": 0.08689778298139572
+ },
+ {
+ "epoch": 5,
+ "loss": 2.1656460762023926,
+ "accuracy": 0.25110000371932983,
+ "mse": 0.08635695278644562
+ },
+ {
+ "epoch": 6,
+ "loss": 2.1532862186431885,
+ "accuracy": 0.25163334608078003,
+ "mse": 0.08654683083295822
+ },
+ {
+ "epoch": 7,
+ "loss": 2.1387012004852295,
+ "accuracy": 0.27480000257492065,
+ "mse": 0.08560030162334442
+ },
+ {
+ "epoch": 8,
+ "loss": 2.112715244293213,
+ "accuracy": 0.2721833288669586,
+ "mse": 0.08543699234724045
+ },
+ {
+ "epoch": 9,
+ "loss": 2.042637586593628,
+ "accuracy": 0.3031499981880188,
+ "mse": 0.08287651091814041
+ },
+ {
+ "epoch": 10,
+ "loss": 2.0273334980010986,
+ "accuracy": 0.29171666502952576,
+ "mse": 0.08358496427536011
+ },
+ {
+ "epoch": 11,
+ "loss": 1.9878947734832764,
+ "accuracy": 0.305649995803833,
+ "mse": 0.08205907046794891
+ },
+ {
+ "epoch": 12,
+ "loss": 1.962004542350769,
+ "accuracy": 0.31371667981147766,
+ "mse": 0.08167976886034012
+ },
+ {
+ "epoch": 13,
+ "loss": 1.9068893194198608,
+ "accuracy": 0.33855000138282776,
+ "mse": 0.08000677824020386
+ },
+ {
+ "epoch": 14,
+ "loss": 1.8864080905914307,
+ "accuracy": 0.3418999910354614,
+ "mse": 0.07973948121070862
+ },
+ {
+ "epoch": 15,
+ "loss": 1.857464075088501,
+ "accuracy": 0.36106666922569275,
+ "mse": 0.0784645825624466
+ },
+ {
+ "epoch": 16,
+ "loss": 1.8311630487442017,
+ "accuracy": 0.3674499988555908,
+ "mse": 0.07762578874826431
+ },
+ {
+ "epoch": 17,
+ "loss": 1.8162471055984497,
+ "accuracy": 0.3792499899864197,
+ "mse": 0.07662363350391388
+ },
+ {
+ "epoch": 18,
+ "loss": 1.7708945274353027,
+ "accuracy": 0.3962833285331726,
+ "mse": 0.07517179101705551
+ },
+ {
+ "epoch": 19,
+ "loss": 1.744101881980896,
+ "accuracy": 0.41518333554267883,
+ "mse": 0.07335612922906876
+ },
+ {
+ "epoch": 20,
+ "loss": 1.7082723379135132,
+ "accuracy": 0.42640000581741333,
+ "mse": 0.07211916148662567
+ },
+ {
+ "epoch": 21,
+ "loss": 1.681416392326355,
+ "accuracy": 0.44369998574256897,
+ "mse": 0.07075273990631104
+ },
+ {
+ "epoch": 22,
+ "loss": 1.6480352878570557,
+ "accuracy": 0.455133318901062,
+ "mse": 0.06965173035860062
+ },
+ {
+ "epoch": 23,
+ "loss": 1.6170828342437744,
+ "accuracy": 0.4739833474159241,
+ "mse": 0.06804250925779343
+ },
+ {
+ "epoch": 24,
+ "loss": 1.5743684768676758,
+ "accuracy": 0.4918833374977112,
+ "mse": 0.0660826563835144
+ },
+ {
+ "epoch": 25,
+ "loss": 1.5484511852264404,
+ "accuracy": 0.5013333559036255,
+ "mse": 0.0652218833565712
+ },
+ {
+ "epoch": 26,
+ "loss": 1.5273946523666382,
+ "accuracy": 0.5122500061988831,
+ "mse": 0.06404848396778107
+ },
+ {
+ "epoch": 27,
+ "loss": 1.498663306236267,
+ "accuracy": 0.5241666436195374,
+ "mse": 0.06252270936965942
+ },
+ {
+ "epoch": 28,
+ "loss": 1.4747557640075684,
+ "accuracy": 0.5364999771118164,
+ "mse": 0.061390221118927
+ },
+ {
+ "epoch": 29,
+ "loss": 1.4553982019424438,
+ "accuracy": 0.5461500287055969,
+ "mse": 0.060323912650346756
+ },
+ {
+ "epoch": 30,
+ "loss": 1.4359486103057861,
+ "accuracy": 0.5573499798774719,
+ "mse": 0.059043750166893005
+ },
+ {
+ "epoch": 31,
+ "loss": 1.4183601140975952,
+ "accuracy": 0.5643666386604309,
+ "mse": 0.058344777673482895
+ },
+ {
+ "epoch": 32,
+ "loss": 1.3956938982009888,
+ "accuracy": 0.5767333507537842,
+ "mse": 0.057140860706567764
+ },
+ {
+ "epoch": 33,
+ "loss": 1.3820492029190063,
+ "accuracy": 0.5805500149726868,
+ "mse": 0.056590963155031204
+ },
+ {
+ "epoch": 34,
+ "loss": 1.3676742315292358,
+ "accuracy": 0.5902000069618225,
+ "mse": 0.05559679865837097
+ },
+ {
+ "epoch": 35,
+ "loss": 1.3519026041030884,
+ "accuracy": 0.5974166393280029,
+ "mse": 0.05482131615281105
+ },
+ {
+ "epoch": 36,
+ "loss": 1.3323968648910522,
+ "accuracy": 0.6051499843597412,
+ "mse": 0.05397596210241318
+ },
+ {
+ "epoch": 37,
+ "loss": 1.3212673664093018,
+ "accuracy": 0.609333336353302,
+ "mse": 0.053337570279836655
+ },
+ {
+ "epoch": 38,
+ "loss": 1.301443338394165,
+ "accuracy": 0.6137333512306213,
+ "mse": 0.05278997868299484
+ },
+ {
+ "epoch": 39,
+ "loss": 1.2748080492019653,
+ "accuracy": 0.6220166683197021,
+ "mse": 0.05200422927737236
+ },
+ {
+ "epoch": 40,
+ "loss": 1.2474853992462158,
+ "accuracy": 0.628333330154419,
+ "mse": 0.05103134736418724
+ },
+ {
+ "epoch": 41,
+ "loss": 1.2331982851028442,
+ "accuracy": 0.6309666633605957,
+ "mse": 0.05071738362312317
+ },
+ {
+ "epoch": 42,
+ "loss": 1.2217841148376465,
+ "accuracy": 0.6347333192825317,
+ "mse": 0.05037698522210121
+ },
+ {
+ "epoch": 43,
+ "loss": 1.2093511819839478,
+ "accuracy": 0.6375499963760376,
+ "mse": 0.05000877007842064
+ },
+ {
+ "epoch": 44,
+ "loss": 1.1889588832855225,
+ "accuracy": 0.6442499756813049,
+ "mse": 0.04940696433186531
+ },
+ {
+ "epoch": 45,
+ "loss": 1.170068621635437,
+ "accuracy": 0.645883321762085,
+ "mse": 0.04878313094377518
+ },
+ {
+ "epoch": 46,
+ "loss": 1.1493510007858276,
+ "accuracy": 0.6541500091552734,
+ "mse": 0.04805826395750046
+ },
+ {
+ "epoch": 47,
+ "loss": 1.1449025869369507,
+ "accuracy": 0.6524166464805603,
+ "mse": 0.04809461906552315
+ },
+ {
+ "epoch": 48,
+ "loss": 1.1348307132720947,
+ "accuracy": 0.656416654586792,
+ "mse": 0.047731198370456696
+ },
+ {
+ "epoch": 49,
+ "loss": 1.1256208419799805,
+ "accuracy": 0.661050021648407,
+ "mse": 0.04709500074386597
+ },
+ {
+ "epoch": 50,
+ "loss": 1.1039165258407593,
+ "accuracy": 0.666266679763794,
+ "mse": 0.04626588523387909
+ },
+ {
+ "epoch": 51,
+ "loss": 1.0950708389282227,
+ "accuracy": 0.6699000000953674,
+ "mse": 0.04597670957446098
+ },
+ {
+ "epoch": 52,
+ "loss": 1.0728211402893066,
+ "accuracy": 0.6717333197593689,
+ "mse": 0.045408837497234344
+ },
+ {
+ "epoch": 53,
+ "loss": 1.0629156827926636,
+ "accuracy": 0.6791333556175232,
+ "mse": 0.04472966492176056
+ },
+ {
+ "epoch": 54,
+ "loss": 1.050464153289795,
+ "accuracy": 0.6791999936103821,
+ "mse": 0.04460533708333969
+ },
+ {
+ "epoch": 55,
+ "loss": 1.0379408597946167,
+ "accuracy": 0.6835500001907349,
+ "mse": 0.04414428398013115
+ },
+ {
+ "epoch": 56,
+ "loss": 1.0258300304412842,
+ "accuracy": 0.683899998664856,
+ "mse": 0.043918028473854065
+ },
+ {
+ "epoch": 57,
+ "loss": 1.0197993516921997,
+ "accuracy": 0.6884499788284302,
+ "mse": 0.04352382570505142
+ },
+ {
+ "epoch": 58,
+ "loss": 1.0007539987564087,
+ "accuracy": 0.6949666738510132,
+ "mse": 0.042678769677877426
+ },
+ {
+ "epoch": 59,
+ "loss": 0.9833020567893982,
+ "accuracy": 0.6977666616439819,
+ "mse": 0.04229569062590599
+ },
+ {
+ "epoch": 60,
+ "loss": 0.9827106595039368,
+ "accuracy": 0.7029333114624023,
+ "mse": 0.041922468692064285
+ },
+ {
+ "epoch": 61,
+ "loss": 0.9729387164115906,
+ "accuracy": 0.7025499939918518,
+ "mse": 0.04178779944777489
+ },
+ {
+ "epoch": 62,
+ "loss": 0.9531602263450623,
+ "accuracy": 0.7073666453361511,
+ "mse": 0.04112190753221512
+ },
+ {
+ "epoch": 63,
+ "loss": 0.9465557336807251,
+ "accuracy": 0.7075833082199097,
+ "mse": 0.040954336524009705
+ },
+ {
+ "epoch": 64,
+ "loss": 0.9330965280532837,
+ "accuracy": 0.7099666595458984,
+ "mse": 0.040666937828063965
+ },
+ {
+ "epoch": 65,
+ "loss": 0.9312558770179749,
+ "accuracy": 0.7093666791915894,
+ "mse": 0.04062912240624428
+ },
+ {
+ "epoch": 66,
+ "loss": 0.9222756624221802,
+ "accuracy": 0.7142000198364258,
+ "mse": 0.040107205510139465
+ },
+ {
+ "epoch": 67,
+ "loss": 0.9147318005561829,
+ "accuracy": 0.7150499820709229,
+ "mse": 0.04001137986779213
+ },
+ {
+ "epoch": 68,
+ "loss": 0.9068416953086853,
+ "accuracy": 0.7188166379928589,
+ "mse": 0.039606932550668716
+ },
+ {
+ "epoch": 69,
+ "loss": 0.8964130878448486,
+ "accuracy": 0.7215666770935059,
+ "mse": 0.03920363634824753
+ },
+ {
+ "epoch": 70,
+ "loss": 0.8832506537437439,
+ "accuracy": 0.7242500185966492,
+ "mse": 0.0387401357293129
+ },
+ {
+ "epoch": 71,
+ "loss": 0.8777680993080139,
+ "accuracy": 0.7267000079154968,
+ "mse": 0.03853677213191986
+ },
+ {
+ "epoch": 72,
+ "loss": 0.8753923177719116,
+ "accuracy": 0.7266333103179932,
+ "mse": 0.038494426757097244
+ },
+ {
+ "epoch": 73,
+ "loss": 0.8701257705688477,
+ "accuracy": 0.7285333275794983,
+ "mse": 0.03827493637800217
+ },
+ {
+ "epoch": 74,
+ "loss": 0.8592549562454224,
+ "accuracy": 0.7321000099182129,
+ "mse": 0.037909746170043945
+ },
+ {
+ "epoch": 75,
+ "loss": 0.8526914119720459,
+ "accuracy": 0.7336333394050598,
+ "mse": 0.03759737312793732
+ },
+ {
+ "epoch": 76,
+ "loss": 0.8415946364402771,
+ "accuracy": 0.7379833459854126,
+ "mse": 0.03705330565571785
+ },
+ {
+ "epoch": 77,
+ "loss": 0.8374033570289612,
+ "accuracy": 0.7420499920845032,
+ "mse": 0.03687801584601402
+ },
+ {
+ "epoch": 78,
+ "loss": 0.829593300819397,
+ "accuracy": 0.7442333102226257,
+ "mse": 0.03650454431772232
+ },
+ {
+ "epoch": 79,
+ "loss": 0.8243364691734314,
+ "accuracy": 0.7472333312034607,
+ "mse": 0.036197930574417114
+ },
+ {
+ "epoch": 80,
+ "loss": 0.8061239719390869,
+ "accuracy": 0.7508833408355713,
+ "mse": 0.035569027066230774
+ },
+ {
+ "epoch": 81,
+ "loss": 0.7960581183433533,
+ "accuracy": 0.7538999915122986,
+ "mse": 0.03511468321084976
+ },
+ {
+ "epoch": 82,
+ "loss": 0.7944959402084351,
+ "accuracy": 0.7525333166122437,
+ "mse": 0.035193998366594315
+ },
+ {
+ "epoch": 83,
+ "loss": 0.7877140641212463,
+ "accuracy": 0.7555666565895081,
+ "mse": 0.03494934365153313
+ },
+ {
+ "epoch": 84,
+ "loss": 0.7787131667137146,
+ "accuracy": 0.7585166692733765,
+ "mse": 0.034488070756196976
+ },
+ {
+ "epoch": 85,
+ "loss": 0.7690148949623108,
+ "accuracy": 0.7598333358764648,
+ "mse": 0.03410160914063454
+ },
+ {
+ "epoch": 86,
+ "loss": 0.7564650774002075,
+ "accuracy": 0.7646999955177307,
+ "mse": 0.03353850916028023
+ },
+ {
+ "epoch": 87,
+ "loss": 0.7516898512840271,
+ "accuracy": 0.7668166756629944,
+ "mse": 0.03323186933994293
+ },
+ {
+ "epoch": 88,
+ "loss": 0.7457777857780457,
+ "accuracy": 0.7681999802589417,
+ "mse": 0.033020392060279846
+ },
+ {
+ "epoch": 89,
+ "loss": 0.7370275855064392,
+ "accuracy": 0.7684500217437744,
+ "mse": 0.03289966657757759
+ },
+ {
+ "epoch": 90,
+ "loss": 0.7254970073699951,
+ "accuracy": 0.7735333442687988,
+ "mse": 0.032172542065382004
+ },
+ {
+ "epoch": 91,
+ "loss": 0.7229769825935364,
+ "accuracy": 0.7741333246231079,
+ "mse": 0.032177019864320755
+ },
+ {
+ "epoch": 92,
+ "loss": 0.7194014191627502,
+ "accuracy": 0.7741333246231079,
+ "mse": 0.031986791640520096
+ },
+ {
+ "epoch": 93,
+ "loss": 0.7130904197692871,
+ "accuracy": 0.7783499956130981,
+ "mse": 0.031523529440164566
+ },
+ {
+ "epoch": 94,
+ "loss": 0.7007499933242798,
+ "accuracy": 0.7826333045959473,
+ "mse": 0.031040064990520477
+ },
+ {
+ "epoch": 95,
+ "loss": 0.6937153935432434,
+ "accuracy": 0.7859333157539368,
+ "mse": 0.03069160133600235
+ },
+ {
+ "epoch": 96,
+ "loss": 0.6844399571418762,
+ "accuracy": 0.7901333570480347,
+ "mse": 0.030151231214404106
+ },
+ {
+ "epoch": 97,
+ "loss": 0.6822003722190857,
+ "accuracy": 0.791183352470398,
+ "mse": 0.03013528697192669
+ },
+ {
+ "epoch": 98,
+ "loss": 0.6799696087837219,
+ "accuracy": 0.7923833131790161,
+ "mse": 0.02994781918823719
+ },
+ {
+ "epoch": 99,
+ "loss": 0.6746756434440613,
+ "accuracy": 0.7930833101272583,
+ "mse": 0.029802365228533745
+ },
+ {
+ "epoch": 100,
+ "loss": 0.6677705645561218,
+ "accuracy": 0.7959833145141602,
+ "mse": 0.029427148401737213
+ },
+ {
+ "epoch": 101,
+ "loss": 0.6636433601379395,
+ "accuracy": 0.7970166802406311,
+ "mse": 0.029296377673745155
+ },
+ {
+ "epoch": 102,
+ "loss": 0.6558457612991333,
+ "accuracy": 0.7995166778564453,
+ "mse": 0.02887680009007454
+ },
+ {
+ "epoch": 103,
+ "loss": 0.6539207100868225,
+ "accuracy": 0.8005499839782715,
+ "mse": 0.02881520800292492
+ },
+ {
+ "epoch": 104,
+ "loss": 0.647727370262146,
+ "accuracy": 0.8004833459854126,
+ "mse": 0.028641220182180405
+ },
+ {
+ "epoch": 105,
+ "loss": 0.6462931036949158,
+ "accuracy": 0.8031666874885559,
+ "mse": 0.028429271653294563
+ },
+ {
+ "epoch": 106,
+ "loss": 0.6405363082885742,
+ "accuracy": 0.8059999942779541,
+ "mse": 0.028048867359757423
+ },
+ {
+ "epoch": 107,
+ "loss": 0.6356658935546875,
+ "accuracy": 0.8066166639328003,
+ "mse": 0.027860259637236595
+ },
+ {
+ "epoch": 108,
+ "loss": 0.633425235748291,
+ "accuracy": 0.8085833191871643,
+ "mse": 0.027679016813635826
+ },
+ {
+ "epoch": 109,
+ "loss": 0.6286950707435608,
+ "accuracy": 0.8079166412353516,
+ "mse": 0.02757597714662552
+ },
+ {
+ "epoch": 110,
+ "loss": 0.6254789233207703,
+ "accuracy": 0.8101333379745483,
+ "mse": 0.027401035651564598
+ },
+ {
+ "epoch": 111,
+ "loss": 0.6202983856201172,
+ "accuracy": 0.8126833438873291,
+ "mse": 0.02701128087937832
+ },
+ {
+ "epoch": 112,
+ "loss": 0.6153184771537781,
+ "accuracy": 0.8144833445549011,
+ "mse": 0.026838423684239388
+ },
+ {
+ "epoch": 113,
+ "loss": 0.6134903430938721,
+ "accuracy": 0.8158166408538818,
+ "mse": 0.026738405227661133
+ },
+ {
+ "epoch": 114,
+ "loss": 0.6093254089355469,
+ "accuracy": 0.8172333240509033,
+ "mse": 0.02652224898338318
+ },
+ {
+ "epoch": 115,
+ "loss": 0.6060876846313477,
+ "accuracy": 0.8166000247001648,
+ "mse": 0.026516789570450783
+ },
+ {
+ "epoch": 116,
+ "loss": 0.6008829474449158,
+ "accuracy": 0.8192833065986633,
+ "mse": 0.026276415213942528
+ },
+ {
+ "epoch": 117,
+ "loss": 0.6001570224761963,
+ "accuracy": 0.8183833360671997,
+ "mse": 0.02626577392220497
+ },
+ {
+ "epoch": 118,
+ "loss": 0.5964875817298889,
+ "accuracy": 0.8196166753768921,
+ "mse": 0.026140645146369934
+ },
+ {
+ "epoch": 119,
+ "loss": 0.5924124717712402,
+ "accuracy": 0.8206666707992554,
+ "mse": 0.025987200438976288
+ },
+ {
+ "epoch": 120,
+ "loss": 0.5898874998092651,
+ "accuracy": 0.8204500079154968,
+ "mse": 0.025896690785884857
+ },
+ {
+ "epoch": 121,
+ "loss": 0.5844441652297974,
+ "accuracy": 0.8232666850090027,
+ "mse": 0.02561897225677967
+ },
+ {
+ "epoch": 122,
+ "loss": 0.5831592082977295,
+ "accuracy": 0.822866678237915,
+ "mse": 0.02556871995329857
+ },
+ {
+ "epoch": 123,
+ "loss": 0.5808939933776855,
+ "accuracy": 0.8241000175476074,
+ "mse": 0.025535941123962402
+ },
+ {
+ "epoch": 124,
+ "loss": 0.5784885287284851,
+ "accuracy": 0.8238333463668823,
+ "mse": 0.02544146031141281
+ },
+ {
+ "epoch": 125,
+ "loss": 0.5744351744651794,
+ "accuracy": 0.8261333107948303,
+ "mse": 0.025155851617455482
+ },
+ {
+ "epoch": 126,
+ "loss": 0.5694005489349365,
+ "accuracy": 0.8266000151634216,
+ "mse": 0.02504907362163067
+ },
+ {
+ "epoch": 127,
+ "loss": 0.5694005489349365,
+ "accuracy": 0.8266000151634216,
+ "mse": 0.02504907362163067
+ },
+ {
+ "epoch": 128,
+ "loss": 0.566077709197998,
+ "accuracy": 0.8271666765213013,
+ "mse": 0.024961115792393684
+ },
+ {
+ "epoch": 129,
+ "loss": 0.561579704284668,
+ "accuracy": 0.8289666771888733,
+ "mse": 0.024858079850673676
+ },
+ {
+ "epoch": 130,
+ "loss": 0.556856632232666,
+ "accuracy": 0.8309000134468079,
+ "mse": 0.024584772065281868
+ },
+ {
+ "epoch": 131,
+ "loss": 0.5551976561546326,
+ "accuracy": 0.8313999772071838,
+ "mse": 0.024584153667092323
+ },
+ {
+ "epoch": 132,
+ "loss": 0.5537286400794983,
+ "accuracy": 0.8321666717529297,
+ "mse": 0.02450234815478325
+ },
+ {
+ "epoch": 133,
+ "loss": 0.5523320436477661,
+ "accuracy": 0.8317499756813049,
+ "mse": 0.024518156424164772
+ },
+ {
+ "epoch": 134,
+ "loss": 0.5500367283821106,
+ "accuracy": 0.8327999711036682,
+ "mse": 0.024318501353263855
+ },
+ {
+ "epoch": 135,
+ "loss": 0.5467727184295654,
+ "accuracy": 0.8338500261306763,
+ "mse": 0.024151477962732315
+ },
+ {
+ "epoch": 136,
+ "loss": 0.5457700490951538,
+ "accuracy": 0.8341833353042603,
+ "mse": 0.024052457883954048
+ },
+ {
+ "epoch": 137,
+ "loss": 0.5439702272415161,
+ "accuracy": 0.8344166874885559,
+ "mse": 0.024046722799539566
+ },
+ {
+ "epoch": 138,
+ "loss": 0.5422022342681885,
+ "accuracy": 0.8356666564941406,
+ "mse": 0.02391701005399227
+ },
+ {
+ "epoch": 139,
+ "loss": 0.5399896502494812,
+ "accuracy": 0.8365333080291748,
+ "mse": 0.023781949654221535
+ },
+ {
+ "epoch": 140,
+ "loss": 0.5386065244674683,
+ "accuracy": 0.8367666602134705,
+ "mse": 0.023783763870596886
+ },
+ {
+ "epoch": 141,
+ "loss": 0.5361820459365845,
+ "accuracy": 0.8368499875068665,
+ "mse": 0.023678092285990715
+ },
+ {
+ "epoch": 142,
+ "loss": 0.5323013067245483,
+ "accuracy": 0.8385000228881836,
+ "mse": 0.023552708327770233
+ },
+ {
+ "epoch": 143,
+ "loss": 0.5309143662452698,
+ "accuracy": 0.8379499912261963,
+ "mse": 0.023511787876486778
+ },
+ {
+ "epoch": 144,
+ "loss": 0.5294746160507202,
+ "accuracy": 0.8386499881744385,
+ "mse": 0.023489996790885925
+ },
+ {
+ "epoch": 145,
+ "loss": 0.5270916819572449,
+ "accuracy": 0.8389166593551636,
+ "mse": 0.02341073378920555
+ },
+ {
+ "epoch": 146,
+ "loss": 0.5256456732749939,
+ "accuracy": 0.8393166661262512,
+ "mse": 0.023342574015259743
+ },
+ {
+ "epoch": 147,
+ "loss": 0.5244222283363342,
+ "accuracy": 0.8402666449546814,
+ "mse": 0.02327417954802513
+ },
+ {
+ "epoch": 148,
+ "loss": 0.5224820375442505,
+ "accuracy": 0.8410666584968567,
+ "mse": 0.023157652467489243
+ },
+ {
+ "epoch": 149,
+ "loss": 0.5204969644546509,
+ "accuracy": 0.8426333069801331,
+ "mse": 0.023019732907414436
+ },
+ {
+ "epoch": 150,
+ "loss": 0.5176105499267578,
+ "accuracy": 0.8433166742324829,
+ "mse": 0.022961517795920372
+ },
+ {
+ "epoch": 151,
+ "loss": 0.5159681439399719,
+ "accuracy": 0.8443166613578796,
+ "mse": 0.02276824600994587
+ },
+ {
+ "epoch": 152,
+ "loss": 0.5138149261474609,
+ "accuracy": 0.8439833521842957,
+ "mse": 0.02277885004878044
+ },
+ {
+ "epoch": 153,
+ "loss": 0.5128265023231506,
+ "accuracy": 0.8446000218391418,
+ "mse": 0.022665750235319138
+ },
+ {
+ "epoch": 154,
+ "loss": 0.5098512768745422,
+ "accuracy": 0.8461999893188477,
+ "mse": 0.02253175526857376
+ },
+ {
+ "epoch": 155,
+ "loss": 0.5073487758636475,
+ "accuracy": 0.8467000126838684,
+ "mse": 0.022416511550545692
+ },
+ {
+ "epoch": 156,
+ "loss": 0.5067659020423889,
+ "accuracy": 0.8470166921615601,
+ "mse": 0.022361373528838158
+ },
+ {
+ "epoch": 157,
+ "loss": 0.5058233737945557,
+ "accuracy": 0.8483166694641113,
+ "mse": 0.02229708805680275
+ },
+ {
+ "epoch": 158,
+ "loss": 0.5053179264068604,
+ "accuracy": 0.8485999703407288,
+ "mse": 0.022308604791760445
+ },
+ {
+ "epoch": 159,
+ "loss": 0.502306342124939,
+ "accuracy": 0.8496833443641663,
+ "mse": 0.022155165672302246
+ },
+ {
+ "epoch": 160,
+ "loss": 0.5006535053253174,
+ "accuracy": 0.8497833609580994,
+ "mse": 0.022141018882393837
+ },
+ {
+ "epoch": 161,
+ "loss": 0.4998496174812317,
+ "accuracy": 0.8496999740600586,
+ "mse": 0.02212020382285118
+ },
+ {
+ "epoch": 162,
+ "loss": 0.4982722997665405,
+ "accuracy": 0.8496000170707703,
+ "mse": 0.02207801677286625
+ },
+ {
+ "epoch": 163,
+ "loss": 0.49557510018348694,
+ "accuracy": 0.8511000275611877,
+ "mse": 0.02192932367324829
+ },
+ {
+ "epoch": 164,
+ "loss": 0.49140802025794983,
+ "accuracy": 0.8531166911125183,
+ "mse": 0.021747851744294167
+ },
+ {
+ "epoch": 165,
+ "loss": 0.49140802025794983,
+ "accuracy": 0.8531166911125183,
+ "mse": 0.021747851744294167
+ },
+ {
+ "epoch": 166,
+ "loss": 0.49128031730651855,
+ "accuracy": 0.8527666926383972,
+ "mse": 0.02170664072036743
+ },
+ {
+ "epoch": 167,
+ "loss": 0.4903290867805481,
+ "accuracy": 0.854200005531311,
+ "mse": 0.021594369783997536
+ },
+ {
+ "epoch": 168,
+ "loss": 0.4891904294490814,
+ "accuracy": 0.853683352470398,
+ "mse": 0.021591292694211006
+ },
+ {
+ "epoch": 169,
+ "loss": 0.4885578453540802,
+ "accuracy": 0.854033350944519,
+ "mse": 0.021563759073615074
+ },
+ {
+ "epoch": 170,
+ "loss": 0.48755013942718506,
+ "accuracy": 0.8541833162307739,
+ "mse": 0.021519312635064125
+ },
+ {
+ "epoch": 171,
+ "loss": 0.48610371351242065,
+ "accuracy": 0.8540499806404114,
+ "mse": 0.021447788923978806
+ },
+ {
+ "epoch": 172,
+ "loss": 0.48458123207092285,
+ "accuracy": 0.8548166751861572,
+ "mse": 0.021398024633526802
+ },
+ {
+ "epoch": 173,
+ "loss": 0.48275795578956604,
+ "accuracy": 0.8558499813079834,
+ "mse": 0.02130713127553463
+ },
+ {
+ "epoch": 174,
+ "loss": 0.481934517621994,
+ "accuracy": 0.8559333086013794,
+ "mse": 0.021283956244587898
+ },
+ {
+ "epoch": 175,
+ "loss": 0.48024967312812805,
+ "accuracy": 0.8563666939735413,
+ "mse": 0.021230099722743034
+ },
+ {
+ "epoch": 176,
+ "loss": 0.4796091914176941,
+ "accuracy": 0.8556333184242249,
+ "mse": 0.021223189309239388
+ },
+ {
+ "epoch": 177,
+ "loss": 0.4789373576641083,
+ "accuracy": 0.855983316898346,
+ "mse": 0.02121482789516449
+ },
+ {
+ "epoch": 178,
+ "loss": 0.47824472188949585,
+ "accuracy": 0.8567333221435547,
+ "mse": 0.02115478180348873
+ },
+ {
+ "epoch": 179,
+ "loss": 0.47732701897621155,
+ "accuracy": 0.8566333055496216,
+ "mse": 0.02115226350724697
+ },
+ {
+ "epoch": 180,
+ "loss": 0.47602227330207825,
+ "accuracy": 0.8565999865531921,
+ "mse": 0.021099673584103584
+ },
+ {
+ "epoch": 181,
+ "loss": 0.4744044542312622,
+ "accuracy": 0.8580499887466431,
+ "mse": 0.020987289026379585
+ },
+ {
+ "epoch": 182,
+ "loss": 0.47319382429122925,
+ "accuracy": 0.8589333295822144,
+ "mse": 0.020937103778123856
+ },
+ {
+ "epoch": 183,
+ "loss": 0.47186610102653503,
+ "accuracy": 0.8585833311080933,
+ "mse": 0.020867936313152313
+ },
+ {
+ "epoch": 184,
+ "loss": 0.4698462188243866,
+ "accuracy": 0.8596333265304565,
+ "mse": 0.020762359723448753
+ },
+ {
+ "epoch": 185,
+ "loss": 0.4686395227909088,
+ "accuracy": 0.859749972820282,
+ "mse": 0.02069973014295101
+ },
+ {
+ "epoch": 186,
+ "loss": 0.46783432364463806,
+ "accuracy": 0.8603500127792358,
+ "mse": 0.02067222259938717
+ },
+ {
+ "epoch": 187,
+ "loss": 0.4664529860019684,
+ "accuracy": 0.8605499863624573,
+ "mse": 0.02058405801653862
+ },
+ {
+ "epoch": 188,
+ "loss": 0.46521663665771484,
+ "accuracy": 0.8606833219528198,
+ "mse": 0.020536044612526894
+ },
+ {
+ "epoch": 189,
+ "loss": 0.4643416702747345,
+ "accuracy": 0.861133337020874,
+ "mse": 0.020498894155025482
+ },
+ {
+ "epoch": 190,
+ "loss": 0.4619861841201782,
+ "accuracy": 0.8620499968528748,
+ "mse": 0.020393557846546173
+ },
+ {
+ "epoch": 191,
+ "loss": 0.4619861841201782,
+ "accuracy": 0.8620499968528748,
+ "mse": 0.020393557846546173
+ },
+ {
+ "epoch": 192,
+ "loss": 0.461443692445755,
+ "accuracy": 0.8616666793823242,
+ "mse": 0.0204488355666399
+ },
+ {
+ "epoch": 193,
+ "loss": 0.45991942286491394,
+ "accuracy": 0.862416684627533,
+ "mse": 0.020406514406204224
+ },
+ {
+ "epoch": 194,
+ "loss": 0.4586426317691803,
+ "accuracy": 0.8626833558082581,
+ "mse": 0.020365921780467033
+ },
+ {
+ "epoch": 195,
+ "loss": 0.4584415555000305,
+ "accuracy": 0.862666666507721,
+ "mse": 0.02038682997226715
+ },
+ {
+ "epoch": 196,
+ "loss": 0.45770150423049927,
+ "accuracy": 0.8629833459854126,
+ "mse": 0.020380565896630287
+ },
+ {
+ "epoch": 197,
+ "loss": 0.4563619792461395,
+ "accuracy": 0.8635333180427551,
+ "mse": 0.020293984562158585
+ },
+ {
+ "epoch": 198,
+ "loss": 0.45534297823905945,
+ "accuracy": 0.8641166687011719,
+ "mse": 0.020256446674466133
+ },
+ {
+ "epoch": 199,
+ "loss": 0.45434120297431946,
+ "accuracy": 0.8644166588783264,
+ "mse": 0.02023407630622387
+ },
+ {
+ "epoch": 200,
+ "loss": 0.4532005488872528,
+ "accuracy": 0.8648999929428101,
+ "mse": 0.020130231976509094
+ },
+ {
+ "epoch": 201,
+ "loss": 0.45199504494667053,
+ "accuracy": 0.8649166822433472,
+ "mse": 0.020107366144657135
+ },
+ {
+ "epoch": 202,
+ "loss": 0.45144906640052795,
+ "accuracy": 0.8652833104133606,
+ "mse": 0.020042145624756813
+ },
+ {
+ "epoch": 203,
+ "loss": 0.4511110782623291,
+ "accuracy": 0.8650000095367432,
+ "mse": 0.02003295347094536
+ },
+ {
+ "epoch": 204,
+ "loss": 0.44950348138809204,
+ "accuracy": 0.8658666610717773,
+ "mse": 0.01993127353489399
+ },
+ {
+ "epoch": 205,
+ "loss": 0.4490715563297272,
+ "accuracy": 0.8665000200271606,
+ "mse": 0.019910326227545738
+ },
+ {
+ "epoch": 206,
+ "loss": 0.44820964336395264,
+ "accuracy": 0.8673333525657654,
+ "mse": 0.019857628270983696
+ },
+ {
+ "epoch": 207,
+ "loss": 0.44650426506996155,
+ "accuracy": 0.8675000071525574,
+ "mse": 0.019839812070131302
+ },
+ {
+ "epoch": 208,
+ "loss": 0.4463881850242615,
+ "accuracy": 0.867900013923645,
+ "mse": 0.019815387204289436
+ },
+ {
+ "epoch": 209,
+ "loss": 0.4456350803375244,
+ "accuracy": 0.8680999875068665,
+ "mse": 0.019761158153414726
+ },
+ {
+ "epoch": 210,
+ "loss": 0.4453062415122986,
+ "accuracy": 0.8674499988555908,
+ "mse": 0.019797610118985176
+ },
+ {
+ "epoch": 211,
+ "loss": 0.44423070549964905,
+ "accuracy": 0.8675833344459534,
+ "mse": 0.019727783277630806
+ },
+ {
+ "epoch": 212,
+ "loss": 0.44324713945388794,
+ "accuracy": 0.8687833547592163,
+ "mse": 0.01965189538896084
+ },
+ {
+ "epoch": 213,
+ "loss": 0.44249972701072693,
+ "accuracy": 0.8688166737556458,
+ "mse": 0.019630303606390953
+ },
+ {
+ "epoch": 214,
+ "loss": 0.4420161247253418,
+ "accuracy": 0.8693166375160217,
+ "mse": 0.019587866961956024
+ },
+ {
+ "epoch": 215,
+ "loss": 0.4414975941181183,
+ "accuracy": 0.8696833252906799,
+ "mse": 0.01953757554292679
+ },
+ {
+ "epoch": 216,
+ "loss": 0.4404485821723938,
+ "accuracy": 0.8704833388328552,
+ "mse": 0.019475681707262993
+ },
+ {
+ "epoch": 217,
+ "loss": 0.4404485821723938,
+ "accuracy": 0.8704833388328552,
+ "mse": 0.019475681707262993
+ },
+ {
+ "epoch": 218,
+ "loss": 0.43964478373527527,
+ "accuracy": 0.8698999881744385,
+ "mse": 0.019477037712931633
+ },
+ {
+ "epoch": 219,
+ "loss": 0.43941107392311096,
+ "accuracy": 0.8705499768257141,
+ "mse": 0.019445881247520447
+ },
+ {
+ "epoch": 220,
+ "loss": 0.4393870532512665,
+ "accuracy": 0.8705000281333923,
+ "mse": 0.019430004060268402
+ },
+ {
+ "epoch": 221,
+ "loss": 0.43862178921699524,
+ "accuracy": 0.870283305644989,
+ "mse": 0.01942402683198452
+ },
+ {
+ "epoch": 222,
+ "loss": 0.43804728984832764,
+ "accuracy": 0.8709999918937683,
+ "mse": 0.0193941667675972
+ },
+ {
+ "epoch": 223,
+ "loss": 0.43755006790161133,
+ "accuracy": 0.871066689491272,
+ "mse": 0.019366292282938957
+ },
+ {
+ "epoch": 224,
+ "loss": 0.4369102418422699,
+ "accuracy": 0.8715500235557556,
+ "mse": 0.019349947571754456
+ },
+ {
+ "epoch": 225,
+ "loss": 0.43603402376174927,
+ "accuracy": 0.8718166947364807,
+ "mse": 0.019267398864030838
+ },
+ {
+ "epoch": 226,
+ "loss": 0.4356696605682373,
+ "accuracy": 0.8715166449546814,
+ "mse": 0.019281014800071716
+ },
+ {
+ "epoch": 227,
+ "loss": 0.43548136949539185,
+ "accuracy": 0.8718000054359436,
+ "mse": 0.019255049526691437
+ },
+ {
+ "epoch": 228,
+ "loss": 0.4346535801887512,
+ "accuracy": 0.8713833093643188,
+ "mse": 0.019244646653532982
+ },
+ {
+ "epoch": 229,
+ "loss": 0.4342179298400879,
+ "accuracy": 0.8719666600227356,
+ "mse": 0.01922900788486004
+ },
+ {
+ "epoch": 230,
+ "loss": 0.4337862730026245,
+ "accuracy": 0.8714666962623596,
+ "mse": 0.019197845831513405
+ },
+ {
+ "epoch": 231,
+ "loss": 0.43340209126472473,
+ "accuracy": 0.8714666962623596,
+ "mse": 0.01917206309735775
+ },
+ {
+ "epoch": 232,
+ "loss": 0.4324895143508911,
+ "accuracy": 0.8715166449546814,
+ "mse": 0.01914064586162567
+ },
+ {
+ "epoch": 233,
+ "loss": 0.4324844777584076,
+ "accuracy": 0.8718833327293396,
+ "mse": 0.019155938178300858
+ },
+ {
+ "epoch": 234,
+ "loss": 0.4319992959499359,
+ "accuracy": 0.8718000054359436,
+ "mse": 0.0191439688205719
+ },
+ {
+ "epoch": 235,
+ "loss": 0.43187132477760315,
+ "accuracy": 0.8719000220298767,
+ "mse": 0.019126655533909798
+ },
+ {
+ "epoch": 236,
+ "loss": 0.43093565106391907,
+ "accuracy": 0.8717833161354065,
+ "mse": 0.019089795649051666
+ },
+ {
+ "epoch": 237,
+ "loss": 0.43093565106391907,
+ "accuracy": 0.8717833161354065,
+ "mse": 0.019089795649051666
+ },
+ {
+ "epoch": 238,
+ "loss": 0.4302520751953125,
+ "accuracy": 0.8720999956130981,
+ "mse": 0.01905098743736744
+ },
+ {
+ "epoch": 239,
+ "loss": 0.4301464557647705,
+ "accuracy": 0.8723333477973938,
+ "mse": 0.019038567319512367
+ },
+ {
+ "epoch": 240,
+ "loss": 0.4296344220638275,
+ "accuracy": 0.8724499940872192,
+ "mse": 0.019024165347218513
+ }
+ ]
+ }
+ ],
+ "completed": true,
+ "valid": true,
+ "error": null
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v4_main_benchmark.csv b/benchmark_results/pso_v4_main_benchmark.csv
new file mode 100644
index 0000000..359a715
--- /dev/null
+++ b/benchmark_results/pso_v4_main_benchmark.csv
@@ -0,0 +1,36 @@
+dataset,method,n_particles,epochs,n_seeds,eval_acc_mean,eval_acc_std,eval_acc_median,eval_acc_iqr,eval_acc_ci95,eval_loss_mean,eval_loss_std,eval_loss_median,eval_loss_iqr,eval_loss_ci95,eval_mse_mean,eval_mse_std,train_acc_mean,train_loss_mean,runtime_seconds_mean,runtime_seconds_std,rank_acc,rank_loss
+Digits,adaptive_moment,24,50,5,0.267778,0.018279,0.272222,0.002778,0.022695,2.108837,0.023357,2.10196,0.039265,0.029001,0.084021,0.001996,0.2718,2.086962,2.499448,0.161274,3,4
+Digits,bare_bones,24,50,5,0.19,0.056266,0.155556,0.1,0.069863,2.250203,0.084448,2.251535,0.020136,0.104855,0.088622,0.003141,0.2,2.230929,2.564876,0.124195,6,6
+Digits,clpso,24,50,5,0.207778,0.050629,0.213889,0.05,0.062863,2.204543,0.023215,2.210108,0.008743,0.028825,0.087396,0.001398,0.223,2.176502,2.519316,0.326734,5,5
+Digits,constriction,24,50,5,0.372778,0.017938,0.380556,0.025,0.022272,1.765113,0.057309,1.760801,0.0677,0.071157,0.074815,0.001608,0.382,1.720719,2.330013,0.148841,1,1
+Digits,fips,24,50,5,0.249444,0.06147,0.263889,0.069444,0.076324,2.064165,0.091569,2.064055,0.108705,0.113696,0.084041,0.002578,0.2662,2.056891,2.621102,0.126036,4,3
+Digits,inertia,24,50,5,0.303333,0.061658,0.305556,0.088889,0.076557,1.980667,0.14307,1.956439,0.144242,0.177642,0.080715,0.004026,0.297,2.014632,2.006851,0.09822,2,2
+Digits,original,24,50,5,0.164444,0.022343,0.158333,0.036111,0.027743,2.269628,0.025331,2.255083,0.030712,0.031453,0.089494,0.000451,0.1798,2.266102,2.272324,0.113557,7,7
+Iris,adaptive_moment,24,60,5,0.846667,0.076739,0.866667,0.133333,0.095283,0.349701,0.178108,0.334009,0.15044,0.221147,0.071416,0.035403,0.89,0.294127,1.392557,0.004708,4,4
+Iris,bare_bones,24,60,5,0.846667,0.055777,0.833333,0.066667,0.069256,0.405791,0.172336,0.367909,0.160981,0.21398,0.072802,0.025814,0.885,0.30248,1.66449,0.144454,5,5
+Iris,clpso,24,60,5,0.793333,0.076012,0.766667,0.066667,0.094379,0.44827,0.053877,0.474597,0.049216,0.066896,0.091464,0.016877,0.78,0.462534,1.86465,0.145025,6,6
+Iris,constriction,24,60,5,0.94,0.036515,0.966667,0.066667,0.045338,0.171796,0.076965,0.148386,0.105914,0.095563,0.033793,0.017284,0.991667,0.032715,1.4309,0.079265,2,2
+Iris,fips,24,60,5,0.74,0.054772,0.733333,0.033333,0.068008,0.60501,0.060601,0.625894,0.064748,0.075245,0.117407,0.008091,0.766667,0.595101,2.072251,0.154361,7,7
+Iris,inertia,24,60,5,0.94,0.027889,0.933333,0.033333,0.034628,0.106901,0.053063,0.108104,0.053939,0.065885,0.024266,0.011903,0.983333,0.040899,1.569569,0.121148,1,1
+Iris,original,24,60,5,0.92,0.086923,0.966667,0.033333,0.107927,0.222324,0.155767,0.192657,0.065706,0.193407,0.043721,0.035081,0.966667,0.08742,1.502316,0.042929,3,3
+MNIST,adaptive_moment,30,80,5,0.262,0.01044,0.269,0.014,0.012963,2.219058,0.104724,2.175837,0.105964,0.13003,0.087089,0.001349,0.2678,2.184856,3.547601,0.614982,4,4
+MNIST,bare_bones,30,80,5,0.4126,0.037958,0.408,0.057,0.04713,1.965562,0.175909,1.989087,0.298842,0.218416,0.077204,0.004802,0.4408,1.8435,3.435835,0.303983,3,3
+MNIST,clpso,30,80,5,0.2068,0.022775,0.2,0.019,0.028278,2.285833,0.068177,2.307686,0.037065,0.084651,0.089514,0.00163,0.2342,2.199232,3.536445,0.226486,6,6
+MNIST,constriction,30,80,5,0.52,0.046244,0.528,0.047,0.057418,1.507968,0.149152,1.509533,0.108216,0.185194,0.063327,0.005427,0.5968,1.284408,3.298112,0.589527,1,1
+MNIST,fips,30,80,5,0.2106,0.048066,0.229,0.04,0.05968,2.22323,0.073048,2.176908,0.130584,0.0907,0.088006,0.001556,0.2302,2.177675,3.806571,0.141017,5,5
+MNIST,inertia,30,80,5,0.4684,0.075252,0.497,0.108,0.093436,1.716089,0.260764,1.620183,0.331954,0.323776,0.070705,0.008553,0.552,1.44457,3.048485,0.155303,2,2
+MNIST,original,30,80,5,0.144,0.016628,0.143,0.026,0.020646,2.428194,0.091877,2.415645,0.154207,0.114079,0.093035,0.001872,0.1563,2.385448,3.490117,0.862784,7,7
+Seeds,adaptive_moment,24,60,5,0.890476,0.046413,0.904762,0.047619,0.057629,0.315947,0.120895,0.278367,0.077865,0.150108,0.053174,0.012296,0.917857,0.225176,1.407326,0.041435,2,1
+Seeds,bare_bones,24,60,5,0.871429,0.068595,0.857143,0.095238,0.08517,0.42192,0.120052,0.439151,0.13714,0.149062,0.069299,0.016028,0.882143,0.348336,1.54165,0.018779,6,5
+Seeds,clpso,24,60,5,0.857143,0.029161,0.857143,0.023809,0.036207,0.469817,0.073254,0.510473,0.12722,0.090955,0.0841,0.011752,0.892857,0.369897,1.537528,0.018265,7,6
+Seeds,constriction,24,60,5,0.890476,0.091597,0.880952,0.095238,0.113731,0.35142,0.3882,0.252366,0.243302,0.482006,0.056642,0.052203,0.960714,0.100819,1.36371,0.053261,3,3
+Seeds,fips,24,60,5,0.885714,0.035315,0.880952,0.02381,0.043849,0.383732,0.103951,0.392303,0.094168,0.12907,0.067541,0.016554,0.9,0.336734,1.815592,0.045394,4,4
+Seeds,inertia,24,60,5,0.914286,0.052164,0.928571,0.023809,0.064769,0.331656,0.342636,0.202104,0.068956,0.425432,0.048999,0.036322,0.963095,0.103132,1.318196,0.015319,1,2
+Seeds,original,24,60,5,0.87619,0.042592,0.880952,0.071429,0.052884,0.49224,0.433653,0.324954,0.104917,0.538443,0.065762,0.028096,0.916667,0.246239,1.385803,0.082957,5,7
+XOR,adaptive_moment,24,80,5,1.0,0.0,1.0,0.0,0.0,0.190431,0.178122,0.197448,0.188515,0.221164,0.04504,0.056878,1.0,0.190431,1.785274,0.092073,5,5
+XOR,bare_bones,24,80,5,1.0,0.0,1.0,0.0,0.0,0.0821,0.056963,0.081613,0.055056,0.070728,0.010907,0.010338,1.0,0.0821,2.031221,0.13707,4,4
+XOR,clpso,24,80,5,0.6,0.136931,0.5,0.25,0.170019,0.548166,0.031946,0.55628,0.024237,0.039666,0.183052,0.012602,0.6,0.548166,2.295572,0.260868,7,7
+XOR,constriction,24,80,5,1.0,0.0,1.0,0.0,0.0,0.004086,0.002357,0.005281,0.001585,0.002927,3.2e-05,1.9e-05,1.0,0.004086,1.987776,0.182034,1,1
+XOR,fips,24,80,5,0.75,0.25,0.75,0.5,0.310411,0.546355,0.059307,0.568609,0.092147,0.073638,0.178887,0.029466,0.75,0.546355,2.502509,0.055447,6,6
+XOR,inertia,24,80,5,1.0,0.0,1.0,0.0,0.0,0.004431,0.003308,0.003801,0.001559,0.004108,3.6e-05,3.1e-05,1.0,0.004431,1.969097,0.170892,2,2
+XOR,original,24,80,5,1.0,0.0,1.0,0.0,0.0,0.004558,0.002672,0.004584,0.001454,0.003318,4.2e-05,2.8e-05,1.0,0.004558,1.905231,0.246635,3,3
diff --git a/benchmark_results/pso_v4_particle_scaling.csv b/benchmark_results/pso_v4_particle_scaling.csv
new file mode 100644
index 0000000..c08a93e
--- /dev/null
+++ b/benchmark_results/pso_v4_particle_scaling.csv
@@ -0,0 +1,41 @@
+method,candidate_label,regimen,n_particles,epochs,particle_epochs,seed,train_loss,train_acc,test_loss,test_acc,test_mse,fit_time_sec,data_fingerprint,model_fingerprint,device
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,30,80,2400,71,1.0238605737686157,0.6834999918937683,1.2778329849243164,0.5789999961853027,0.05719960853457451,2.591740084113553,dfe645918ece54c0,0777bd52fd76272d,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,30,80,2400,72,1.0670214891433716,0.6604999899864197,1.199388861656189,0.6060000061988831,0.052410222589969635,2.7087553329765797,dfe645918ece54c0,6fcb6e473bdacbd2,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,30,80,2400,73,0.9569582939147949,0.7014999985694885,1.1562552452087402,0.6389999985694885,0.051246583461761475,2.6669440830592066,dfe645918ece54c0,2e6c351372592f10,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,30,80,2400,74,0.8988860845565796,0.718999981880188,1.0667707920074463,0.6589999794960022,0.047151338309049606,2.6316912909969687,dfe645918ece54c0,4000fe3fb26ef207,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,30,80,2400,75,0.9674410820007324,0.7139999866485596,1.2670954465866089,0.6230000257492065,0.052300941199064255,2.8266918330918998,dfe645918ece54c0,0966039f5ef7af88,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,60,80,4800,71,0.8341852426528931,0.7419999837875366,1.021918535232544,0.6729999780654907,0.0449918694794178,6.297774499980733,dfe645918ece54c0,0777bd52fd76272d,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,60,80,4800,72,0.8334679007530212,0.7580000162124634,1.1486669778823853,0.6499999761581421,0.048473432660102844,5.944013542030007,dfe645918ece54c0,6fcb6e473bdacbd2,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,60,80,4800,73,0.7845665216445923,0.7599999904632568,1.059795618057251,0.6589999794960022,0.04623967781662941,5.409191000042483,dfe645918ece54c0,2e6c351372592f10,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,60,80,4800,74,0.8425021767616272,0.7400000095367432,1.0703872442245483,0.6610000133514404,0.046978432685136795,5.092122667003423,dfe645918ece54c0,4000fe3fb26ef207,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,60,80,4800,75,0.7727756500244141,0.753000020980835,1.0723776817321777,0.6539999842643738,0.04744390770792961,5.18646250013262,dfe645918ece54c0,0966039f5ef7af88,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,90,80,7200,71,0.6898615956306458,0.7910000085830688,0.8688502311706543,0.7310000061988831,0.03894031420350075,8.216789624886587,dfe645918ece54c0,0777bd52fd76272d,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,90,80,7200,72,0.7159585952758789,0.781499981880188,0.9239839911460876,0.718999981880188,0.040356870740652084,8.96910895803012,dfe645918ece54c0,6fcb6e473bdacbd2,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,90,80,7200,73,0.738656759262085,0.7760000228881836,0.9498289227485657,0.6959999799728394,0.04225980117917061,9.117825584020466,dfe645918ece54c0,2e6c351372592f10,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,90,80,7200,74,0.7267816066741943,0.7770000100135803,0.954045295715332,0.6769999861717224,0.04218713194131851,8.722332582809031,dfe645918ece54c0,4000fe3fb26ef207,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,90,80,7200,75,0.7104133367538452,0.7889999747276306,0.962693989276886,0.6930000185966492,0.04196783900260925,8.110321166925132,dfe645918ece54c0,0966039f5ef7af88,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,120,80,9600,71,0.6516683101654053,0.7950000166893005,0.8584634065628052,0.7360000014305115,0.037673790007829666,11.962705624988303,dfe645918ece54c0,0777bd52fd76272d,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,120,80,9600,72,0.6982801556587219,0.7914999723434448,0.9025362133979797,0.7239999771118164,0.038956169039011,11.906837583053857,dfe645918ece54c0,6fcb6e473bdacbd2,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,120,80,9600,73,0.7527623772621155,0.7749999761581421,1.001193642616272,0.6919999718666077,0.04309915751218796,10.664651792030782,dfe645918ece54c0,2e6c351372592f10,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,120,80,9600,74,0.6858600974082947,0.784500002861023,0.8601324558258057,0.7350000143051147,0.03845023736357689,10.921957665821537,dfe645918ece54c0,4000fe3fb26ef207,mps
+adaptive_moment,am_b0.06_s0.5,fixed_epoch,120,80,9600,75,0.6326538324356079,0.8125,0.889915406703949,0.7300000190734863,0.03931796923279762,10.411899874918163,dfe645918ece54c0,0966039f5ef7af88,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,30,80,2400,71,1.0238605737686157,0.6834999918937683,1.2778329849243164,0.5789999961853027,0.05719960853457451,2.591740084113553,dfe645918ece54c0,0777bd52fd76272d,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,30,80,2400,72,1.0670214891433716,0.6604999899864197,1.199388861656189,0.6060000061988831,0.052410222589969635,2.7087553329765797,dfe645918ece54c0,6fcb6e473bdacbd2,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,30,80,2400,73,0.9569582939147949,0.7014999985694885,1.1562552452087402,0.6389999985694885,0.051246583461761475,2.6669440830592066,dfe645918ece54c0,2e6c351372592f10,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,30,80,2400,74,0.8988860845565796,0.718999981880188,1.0667707920074463,0.6589999794960022,0.047151338309049606,2.6316912909969687,dfe645918ece54c0,4000fe3fb26ef207,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,30,80,2400,75,0.9674410820007324,0.7139999866485596,1.2670954465866089,0.6230000257492065,0.052300941199064255,2.8266918330918998,dfe645918ece54c0,0966039f5ef7af88,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,60,40,2400,71,1.3702143430709839,0.5690000057220459,1.5396113395690918,0.49000000953674316,0.06583584100008011,2.6427467500325292,dfe645918ece54c0,0777bd52fd76272d,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,60,40,2400,72,1.3834563493728638,0.5490000247955322,1.564630150794983,0.5270000100135803,0.06432151794433594,2.897082625189796,dfe645918ece54c0,6fcb6e473bdacbd2,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,60,40,2400,73,1.239696979522705,0.6129999756813049,1.4340611696243286,0.5109999775886536,0.06299576163291931,2.8362932079471648,dfe645918ece54c0,2e6c351372592f10,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,60,40,2400,74,1.3051151037216187,0.593500018119812,1.4914799928665161,0.5370000004768372,0.06303515285253525,2.7601085831411183,dfe645918ece54c0,4000fe3fb26ef207,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,60,40,2400,75,1.23734712600708,0.6150000095367432,1.6433888673782349,0.47200000286102295,0.07071221619844437,2.791566374944523,dfe645918ece54c0,0966039f5ef7af88,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,90,27,2430,71,1.454797387123108,0.5099999904632568,1.7139235734939575,0.40400001406669617,0.07408219575881958,3.001450875075534,dfe645918ece54c0,0777bd52fd76272d,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,90,27,2430,72,1.436651349067688,0.5364999771118164,1.525922417640686,0.5180000066757202,0.06329239904880524,2.9281624578870833,dfe645918ece54c0,6fcb6e473bdacbd2,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,90,27,2430,73,1.5700972080230713,0.4805000126361847,1.7064924240112305,0.4180000126361847,0.07409033179283142,3.446030291961506,dfe645918ece54c0,2e6c351372592f10,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,90,27,2430,74,1.4872608184814453,0.5425000190734863,1.6065630912780762,0.5059999823570251,0.06642712652683258,3.13685941696167,dfe645918ece54c0,4000fe3fb26ef207,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,90,27,2430,75,1.4402897357940674,0.5699999928474426,1.5009552240371704,0.5450000166893005,0.06177634745836258,3.0350140419322997,dfe645918ece54c0,0966039f5ef7af88,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,120,20,2400,71,1.5967158079147339,0.4830000102519989,1.7100492715835571,0.43799999356269836,0.07075551897287369,3.14462749985978,dfe645918ece54c0,0777bd52fd76272d,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,120,20,2400,72,1.673862338066101,0.46149998903274536,1.8141505718231201,0.4099999964237213,0.07267315685749054,3.102293625008315,dfe645918ece54c0,6fcb6e473bdacbd2,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,120,20,2400,73,1.7135908603668213,0.4449999928474426,1.8838708400726318,0.375,0.0778227150440216,2.7550693340599537,dfe645918ece54c0,2e6c351372592f10,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,120,20,2400,74,1.5981744527816772,0.49950000643730164,1.7434691190719604,0.42399999499320984,0.07240629941225052,2.9445771670434624,dfe645918ece54c0,4000fe3fb26ef207,mps
+adaptive_moment,am_b0.06_s0.5,fixed_budget,120,20,2400,75,1.635738730430603,0.46950000524520874,1.8486356735229492,0.4059999883174896,0.07580890506505966,3.1960245410446078,dfe645918ece54c0,0966039f5ef7af88,mps
diff --git a/benchmark_results/pso_v4_tuning.json b/benchmark_results/pso_v4_tuning.json
new file mode 100644
index 0000000..cc54ac2
--- /dev/null
+++ b/benchmark_results/pso_v4_tuning.json
@@ -0,0 +1,20423 @@
+{
+ "tuning_protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "quick": false,
+ "device": "mps",
+ "timestamp": "2026-09-01 07:10:25",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "split_fingerprints": {
+ "search_inner": "bfc8de485755d7f3",
+ "full": "dfe645918ece54c0"
+ },
+ "pca_provenance": {
+ "search": {
+ "n_samples_fit": 2400,
+ "n_samples_val": 600,
+ "n_components": 32,
+ "whiten": true,
+ "random_state": 42,
+ "explained_variance_ratio_sum": 0.7540379762649536
+ },
+ "full": {
+ "n_samples_fit": 3000,
+ "n_samples_test": 1000,
+ "n_components": 32,
+ "whiten": true,
+ "random_state": 42,
+ "explained_variance_ratio_sum": 0.7533358931541443
+ }
+ },
+ "selection_criteria": "Validation accuracy descending, then validation loss ascending across required search seeds",
+ "winners": {
+ "adaptive_moment": {
+ "candidate_label": "am_b0.06_s0.5",
+ "mean_val_loss": 0.9509724179903666,
+ "mean_val_acc": 0.7016666730244955,
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ }
+ }
+ },
+ "inertia": {
+ "candidate_label": "inertia_asymmetric",
+ "mean_val_loss": 1.0291322271029155,
+ "mean_val_acc": 0.6972222129503886,
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "constriction": {
+ "candidate_label": "constriction_c205_canonical",
+ "mean_val_loss": 0.9844014843304952,
+ "mean_val_acc": 0.7088888883590698,
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.05,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05
+ }
+ },
+ "local_best": {
+ "candidate_label": "local_best_r4_constant",
+ "mean_val_loss": 0.9449125925699869,
+ "mean_val_acc": 0.7244444489479065,
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 4,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ }
+ },
+ "quantum": {
+ "candidate_label": "quantum_beta_0.4_0.9",
+ "mean_val_loss": 1.337708830833435,
+ "mean_val_acc": 0.5649999976158142,
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ }
+ }
+ }
+ },
+ "summaries": {
+ "search": {
+ "am_b0.03_s0.5": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s0.5",
+ "val_accs": [
+ 0.6633333563804626,
+ 0.6816666722297668,
+ 0.6883333325386047
+ ],
+ "val_losses": [
+ 1.0964455604553223,
+ 1.0115970373153687,
+ 0.9940392971038818
+ ],
+ "fit_times": [
+ 2.5230953749269247,
+ 2.5447300830855966,
+ 2.493663167115301
+ ],
+ "val_acc_stats": {
+ "mean": 0.677778,
+ "std": 0.012946,
+ "median": 0.681667,
+ "iqr": 0.0125,
+ "ci95_t": 0.032159
+ },
+ "val_loss_stats": {
+ "mean": 1.034027,
+ "std": 0.054764,
+ "median": 1.011597,
+ "iqr": 0.051203,
+ "ci95_t": 0.136043
+ },
+ "fit_time_stats": {
+ "mean": 2.520496,
+ "std": 0.025632,
+ "median": 2.523095,
+ "iqr": 0.025533,
+ "ci95_t": 0.063675
+ }
+ },
+ "am_b0.03_s1.0": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s1.0",
+ "val_accs": [
+ 0.6850000023841858,
+ 0.6933333277702332,
+ 0.6850000023841858
+ ],
+ "val_losses": [
+ 1.0240328311920166,
+ 0.9720749855041504,
+ 1.081996202468872
+ ],
+ "fit_times": [
+ 2.54264641716145,
+ 2.491340707987547,
+ 2.633713499875739
+ ],
+ "val_acc_stats": {
+ "mean": 0.687778,
+ "std": 0.004811,
+ "median": 0.685,
+ "iqr": 0.004167,
+ "ci95_t": 0.011952
+ },
+ "val_loss_stats": {
+ "mean": 1.026035,
+ "std": 0.054988,
+ "median": 1.024033,
+ "iqr": 0.054961,
+ "ci95_t": 0.136599
+ },
+ "fit_time_stats": {
+ "mean": 2.5559,
+ "std": 0.072106,
+ "median": 2.542646,
+ "iqr": 0.071186,
+ "ci95_t": 0.179123
+ }
+ },
+ "am_b0.03_s1.5": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s1.5",
+ "val_accs": [
+ 0.6850000023841858,
+ 0.7266666889190674,
+ 0.6833333373069763
+ ],
+ "val_losses": [
+ 1.030881404876709,
+ 0.8990310430526733,
+ 1.0034033060073853
+ ],
+ "fit_times": [
+ 2.8367540831677616,
+ 2.5477614579722285,
+ 2.5643632498104125
+ ],
+ "val_acc_stats": {
+ "mean": 0.698333,
+ "std": 0.024552,
+ "median": 0.685,
+ "iqr": 0.021667,
+ "ci95_t": 0.06099
+ },
+ "val_loss_stats": {
+ "mean": 0.977772,
+ "std": 0.069562,
+ "median": 1.003403,
+ "iqr": 0.065925,
+ "ci95_t": 0.172803
+ },
+ "fit_time_stats": {
+ "mean": 2.649626,
+ "std": 0.16227,
+ "median": 2.564363,
+ "iqr": 0.144496,
+ "ci95_t": 0.403105
+ }
+ },
+ "am_b0.06_s0.5": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "val_accs": [
+ 0.675000011920929,
+ 0.7083333134651184,
+ 0.721666693687439
+ ],
+ "val_losses": [
+ 1.0220483541488647,
+ 0.9152445197105408,
+ 0.9156243801116943
+ ],
+ "fit_times": [
+ 2.6285997920203954,
+ 2.7918378338217735,
+ 2.729898874880746
+ ],
+ "val_acc_stats": {
+ "mean": 0.701667,
+ "std": 0.024037,
+ "median": 0.708333,
+ "iqr": 0.023333,
+ "ci95_t": 0.059712
+ },
+ "val_loss_stats": {
+ "mean": 0.950972,
+ "std": 0.061554,
+ "median": 0.915624,
+ "iqr": 0.053402,
+ "ci95_t": 0.15291
+ },
+ "fit_time_stats": {
+ "mean": 2.716779,
+ "std": 0.082406,
+ "median": 2.729899,
+ "iqr": 0.081619,
+ "ci95_t": 0.20471
+ }
+ },
+ "am_b0.06_s1.0": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0",
+ "val_accs": [
+ 0.6899999976158142,
+ 0.6933333277702332,
+ 0.7083333134651184
+ ],
+ "val_losses": [
+ 0.9721739888191223,
+ 0.9488086104393005,
+ 0.9320653080940247
+ ],
+ "fit_times": [
+ 2.5812953328713775,
+ 2.8018474159762263,
+ 2.7171109160408378
+ ],
+ "val_acc_stats": {
+ "mean": 0.697222,
+ "std": 0.009766,
+ "median": 0.693333,
+ "iqr": 0.009167,
+ "ci95_t": 0.02426
+ },
+ "val_loss_stats": {
+ "mean": 0.951016,
+ "std": 0.020145,
+ "median": 0.948809,
+ "iqr": 0.020054,
+ "ci95_t": 0.050044
+ },
+ "fit_time_stats": {
+ "mean": 2.700085,
+ "std": 0.111257,
+ "median": 2.717111,
+ "iqr": 0.110276,
+ "ci95_t": 0.276382
+ }
+ },
+ "am_b0.06_s1.5": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.5",
+ "val_accs": [
+ 0.6650000214576721,
+ 0.6833333373069763,
+ 0.6499999761581421
+ ],
+ "val_losses": [
+ 1.1235008239746094,
+ 1.0213521718978882,
+ 1.0920277833938599
+ ],
+ "fit_times": [
+ 2.7500752080231905,
+ 3.103288209065795,
+ 2.862214791122824
+ ],
+ "val_acc_stats": {
+ "mean": 0.666111,
+ "std": 0.016694,
+ "median": 0.665,
+ "iqr": 0.016667,
+ "ci95_t": 0.041472
+ },
+ "val_loss_stats": {
+ "mean": 1.07896,
+ "std": 0.052313,
+ "median": 1.092028,
+ "iqr": 0.051074,
+ "ci95_t": 0.129954
+ },
+ "fit_time_stats": {
+ "mean": 2.905193,
+ "std": 0.180486,
+ "median": 2.862215,
+ "iqr": 0.176607,
+ "ci95_t": 0.448357
+ }
+ },
+ "am_b0.1_s0.5": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s0.5",
+ "val_accs": [
+ 0.6766666769981384,
+ 0.6983333230018616,
+ 0.7283333539962769
+ ],
+ "val_losses": [
+ 1.0877516269683838,
+ 0.9451570510864258,
+ 0.8658249974250793
+ ],
+ "fit_times": [
+ 2.8528131251223385,
+ 2.7851123749278486,
+ 2.7191387079656124
+ ],
+ "val_acc_stats": {
+ "mean": 0.701111,
+ "std": 0.025945,
+ "median": 0.698333,
+ "iqr": 0.025833,
+ "ci95_t": 0.064452
+ },
+ "val_loss_stats": {
+ "mean": 0.966245,
+ "std": 0.112456,
+ "median": 0.945157,
+ "iqr": 0.110963,
+ "ci95_t": 0.279359
+ },
+ "fit_time_stats": {
+ "mean": 2.785688,
+ "std": 0.066839,
+ "median": 2.785112,
+ "iqr": 0.066837,
+ "ci95_t": 0.166039
+ }
+ },
+ "am_b0.1_s1.0": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s1.0",
+ "val_accs": [
+ 0.7016666531562805,
+ 0.6966666579246521,
+ 0.6783333420753479
+ ],
+ "val_losses": [
+ 0.9926102757453918,
+ 1.009635329246521,
+ 1.0561128854751587
+ ],
+ "fit_times": [
+ 2.8380547501146793,
+ 2.905045999912545,
+ 2.7804793331306428
+ ],
+ "val_acc_stats": {
+ "mean": 0.692222,
+ "std": 0.012285,
+ "median": 0.696667,
+ "iqr": 0.011667,
+ "ci95_t": 0.030518
+ },
+ "val_loss_stats": {
+ "mean": 1.019453,
+ "std": 0.03287,
+ "median": 1.009635,
+ "iqr": 0.031751,
+ "ci95_t": 0.081654
+ },
+ "fit_time_stats": {
+ "mean": 2.841193,
+ "std": 0.062343,
+ "median": 2.838055,
+ "iqr": 0.062283,
+ "ci95_t": 0.154869
+ }
+ },
+ "am_b0.1_s1.5": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s1.5",
+ "val_accs": [
+ 0.6899999976158142,
+ 0.6966666579246521,
+ 0.6850000023841858
+ ],
+ "val_losses": [
+ 1.00997793674469,
+ 1.063821792602539,
+ 1.0491483211517334
+ ],
+ "fit_times": [
+ 2.8892802079208195,
+ 2.669369083130732,
+ 2.626303083030507
+ ],
+ "val_acc_stats": {
+ "mean": 0.690556,
+ "std": 0.005853,
+ "median": 0.69,
+ "iqr": 0.005833,
+ "ci95_t": 0.01454
+ },
+ "val_loss_stats": {
+ "mean": 1.040983,
+ "std": 0.027835,
+ "median": 1.049148,
+ "iqr": 0.026922,
+ "ci95_t": 0.069147
+ },
+ "fit_time_stats": {
+ "mean": 2.728317,
+ "std": 0.141051,
+ "median": 2.669369,
+ "iqr": 0.131489,
+ "ci95_t": 0.350394
+ }
+ },
+ "am_b0.15_s0.5": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s0.5",
+ "val_accs": [
+ 0.6600000262260437,
+ 0.7300000190734863,
+ 0.70333331823349
+ ],
+ "val_losses": [
+ 1.1322306394577026,
+ 0.9312149882316589,
+ 0.9656715989112854
+ ],
+ "fit_times": [
+ 2.5766194579191506,
+ 2.731992583023384,
+ 3.0274115409702063
+ ],
+ "val_acc_stats": {
+ "mean": 0.697778,
+ "std": 0.035329,
+ "median": 0.703333,
+ "iqr": 0.035,
+ "ci95_t": 0.087763
+ },
+ "val_loss_stats": {
+ "mean": 1.009706,
+ "std": 0.107499,
+ "median": 0.965672,
+ "iqr": 0.100508,
+ "ci95_t": 0.267046
+ },
+ "fit_time_stats": {
+ "mean": 2.778675,
+ "std": 0.228993,
+ "median": 2.731993,
+ "iqr": 0.225396,
+ "ci95_t": 0.568856
+ }
+ },
+ "am_b0.15_s1.0": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s1.0",
+ "val_accs": [
+ 0.7166666388511658,
+ 0.6949999928474426,
+ 0.6866666674613953
+ ],
+ "val_losses": [
+ 0.9564719796180725,
+ 0.9963273406028748,
+ 1.0127019882202148
+ ],
+ "fit_times": [
+ 2.9793542500119656,
+ 2.8151185419410467,
+ 3.0412363330833614
+ ],
+ "val_acc_stats": {
+ "mean": 0.699444,
+ "std": 0.015486,
+ "median": 0.695,
+ "iqr": 0.015,
+ "ci95_t": 0.03847
+ },
+ "val_loss_stats": {
+ "mean": 0.9885,
+ "std": 0.028921,
+ "median": 0.996327,
+ "iqr": 0.028115,
+ "ci95_t": 0.071843
+ },
+ "fit_time_stats": {
+ "mean": 2.945236,
+ "std": 0.116856,
+ "median": 2.979354,
+ "iqr": 0.113059,
+ "ci95_t": 0.29029
+ }
+ },
+ "am_b0.15_s1.5": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s1.5",
+ "val_accs": [
+ 0.6133333444595337,
+ 0.6966666579246521,
+ 0.6983333230018616
+ ],
+ "val_losses": [
+ 1.2029211521148682,
+ 1.0831577777862549,
+ 0.9602290987968445
+ ],
+ "fit_times": [
+ 3.1714885828550905,
+ 2.993674041936174,
+ 2.7658886671997607
+ ],
+ "val_acc_stats": {
+ "mean": 0.669444,
+ "std": 0.048601,
+ "median": 0.696667,
+ "iqr": 0.0425,
+ "ci95_t": 0.120732
+ },
+ "val_loss_stats": {
+ "mean": 1.082103,
+ "std": 0.121349,
+ "median": 1.083158,
+ "iqr": 0.121346,
+ "ci95_t": 0.301452
+ },
+ "fit_time_stats": {
+ "mean": 2.977017,
+ "std": 0.203312,
+ "median": 2.993674,
+ "iqr": 0.2028,
+ "ci95_t": 0.505061
+ }
+ },
+ "am_b0.06_s1.0_beta0.8": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0_beta0.8",
+ "val_accs": [
+ 0.6700000166893005,
+ 0.6683333516120911,
+ 0.70333331823349
+ ],
+ "val_losses": [
+ 1.1239941120147705,
+ 1.0324488878250122,
+ 0.938503623008728
+ ],
+ "fit_times": [
+ 2.764871333958581,
+ 2.830462665995583,
+ 2.8122877080459148
+ ],
+ "val_acc_stats": {
+ "mean": 0.680556,
+ "std": 0.019744,
+ "median": 0.67,
+ "iqr": 0.0175,
+ "ci95_t": 0.049047
+ },
+ "val_loss_stats": {
+ "mean": 1.031649,
+ "std": 0.092748,
+ "median": 1.032449,
+ "iqr": 0.092745,
+ "ci95_t": 0.230401
+ },
+ "fit_time_stats": {
+ "mean": 2.802541,
+ "std": 0.033865,
+ "median": 2.812288,
+ "iqr": 0.032796,
+ "ci95_t": 0.084125
+ }
+ },
+ "am_b0.06_s1.0_beta0.95": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0_beta0.95",
+ "val_accs": [
+ 0.6800000071525574,
+ 0.6833333373069763,
+ 0.6683333516120911
+ ],
+ "val_losses": [
+ 1.0093973875045776,
+ 0.9828318357467651,
+ 1.0834088325500488
+ ],
+ "fit_times": [
+ 2.9217382080387324,
+ 2.777603624854237,
+ 3.0502532080281526
+ ],
+ "val_acc_stats": {
+ "mean": 0.677222,
+ "std": 0.007876,
+ "median": 0.68,
+ "iqr": 0.0075,
+ "ci95_t": 0.019566
+ },
+ "val_loss_stats": {
+ "mean": 1.025213,
+ "std": 0.05212,
+ "median": 1.009397,
+ "iqr": 0.050288,
+ "ci95_t": 0.129475
+ },
+ "fit_time_stats": {
+ "mean": 2.916532,
+ "std": 0.136399,
+ "median": 2.921738,
+ "iqr": 0.136325,
+ "ci95_t": 0.338838
+ }
+ },
+ "inertia_canonical": {
+ "method": "inertia",
+ "candidate_label": "inertia_canonical",
+ "val_accs": [
+ 0.6000000238418579,
+ 0.5066666603088379,
+ 0.5683333277702332
+ ],
+ "val_losses": [
+ 1.4125466346740723,
+ 1.6294100284576416,
+ 1.4316622018814087
+ ],
+ "fit_times": [
+ 3.098805333022028,
+ 2.652766958111897,
+ 2.529014667030424
+ ],
+ "val_acc_stats": {
+ "mean": 0.558333,
+ "std": 0.047463,
+ "median": 0.568333,
+ "iqr": 0.046667,
+ "ci95_t": 0.117907
+ },
+ "val_loss_stats": {
+ "mean": 1.491206,
+ "std": 0.120069,
+ "median": 1.431662,
+ "iqr": 0.108432,
+ "ci95_t": 0.298271
+ },
+ "fit_time_stats": {
+ "mean": 2.760196,
+ "std": 0.299702,
+ "median": 2.652767,
+ "iqr": 0.284895,
+ "ci95_t": 0.744508
+ }
+ },
+ "inertia_tuned": {
+ "method": "inertia",
+ "candidate_label": "inertia_tuned",
+ "val_accs": [
+ 0.6816666722297668,
+ 0.7250000238418579,
+ 0.6766666769981384
+ ],
+ "val_losses": [
+ 1.0345858335494995,
+ 0.9224241375923157,
+ 1.0678696632385254
+ ],
+ "fit_times": [
+ 2.626064541982487,
+ 2.5009557919111103,
+ 2.4420957090333104
+ ],
+ "val_acc_stats": {
+ "mean": 0.694444,
+ "std": 0.02658,
+ "median": 0.681667,
+ "iqr": 0.024167,
+ "ci95_t": 0.066028
+ },
+ "val_loss_stats": {
+ "mean": 1.008293,
+ "std": 0.076204,
+ "median": 1.034586,
+ "iqr": 0.072723,
+ "ci95_t": 0.189304
+ },
+ "fit_time_stats": {
+ "mean": 2.523039,
+ "std": 0.093951,
+ "median": 2.500956,
+ "iqr": 0.091984,
+ "ci95_t": 0.233391
+ }
+ },
+ "inertia_low_w": {
+ "method": "inertia",
+ "candidate_label": "inertia_low_w",
+ "val_accs": [
+ 0.6850000023841858,
+ 0.70333331823349,
+ 0.6983333230018616
+ ],
+ "val_losses": [
+ 1.0575727224349976,
+ 0.9806669354438782,
+ 0.9656168818473816
+ ],
+ "fit_times": [
+ 2.484879707917571,
+ 2.643615792039782,
+ 2.4834530411753803
+ ],
+ "val_acc_stats": {
+ "mean": 0.695556,
+ "std": 0.009477,
+ "median": 0.698333,
+ "iqr": 0.009167,
+ "ci95_t": 0.023543
+ },
+ "val_loss_stats": {
+ "mean": 1.001286,
+ "std": 0.049324,
+ "median": 0.980667,
+ "iqr": 0.045978,
+ "ci95_t": 0.122528
+ },
+ "fit_time_stats": {
+ "mean": 2.537316,
+ "std": 0.092061,
+ "median": 2.48488,
+ "iqr": 0.080081,
+ "ci95_t": 0.228695
+ }
+ },
+ "inertia_w_decay": {
+ "method": "inertia",
+ "candidate_label": "inertia_w_decay",
+ "val_accs": [
+ 0.6983333230018616,
+ 0.6700000166893005,
+ 0.6816666722297668
+ ],
+ "val_losses": [
+ 1.025821566581726,
+ 1.1661359071731567,
+ 0.9870904684066772
+ ],
+ "fit_times": [
+ 2.426888459129259,
+ 2.480164624983445,
+ 2.422041916055605
+ ],
+ "val_acc_stats": {
+ "mean": 0.683333,
+ "std": 0.01424,
+ "median": 0.681667,
+ "iqr": 0.014167,
+ "ci95_t": 0.035374
+ },
+ "val_loss_stats": {
+ "mean": 1.059683,
+ "std": 0.094203,
+ "median": 1.025822,
+ "iqr": 0.089523,
+ "ci95_t": 0.234016
+ },
+ "fit_time_stats": {
+ "mean": 2.443032,
+ "std": 0.032249,
+ "median": 2.426888,
+ "iqr": 0.029061,
+ "ci95_t": 0.080112
+ }
+ },
+ "inertia_asymmetric": {
+ "method": "inertia",
+ "candidate_label": "inertia_asymmetric",
+ "val_accs": [
+ 0.6949999928474426,
+ 0.6933333277702332,
+ 0.70333331823349
+ ],
+ "val_losses": [
+ 1.0954482555389404,
+ 1.0121054649353027,
+ 0.9798429608345032
+ ],
+ "fit_times": [
+ 2.485565959010273,
+ 2.5209125420078635,
+ 2.5959840829018503
+ ],
+ "val_acc_stats": {
+ "mean": 0.697222,
+ "std": 0.005358,
+ "median": 0.695,
+ "iqr": 0.005,
+ "ci95_t": 0.013309
+ },
+ "val_loss_stats": {
+ "mean": 1.029132,
+ "std": 0.059654,
+ "median": 1.012105,
+ "iqr": 0.057803,
+ "ci95_t": 0.14819
+ },
+ "fit_time_stats": {
+ "mean": 2.534154,
+ "std": 0.056387,
+ "median": 2.520913,
+ "iqr": 0.055209,
+ "ci95_t": 0.140076
+ }
+ },
+ "constriction_c201": {
+ "method": "constriction",
+ "candidate_label": "constriction_c201",
+ "val_accs": [
+ 0.6916666626930237,
+ 0.6883333325386047,
+ 0.7166666388511658
+ ],
+ "val_losses": [
+ 0.9738073945045471,
+ 1.0523117780685425,
+ 0.9275049567222595
+ ],
+ "fit_times": [
+ 2.698073250008747,
+ 3.4117308750282973,
+ 3.1805959579069167
+ ],
+ "val_acc_stats": {
+ "mean": 0.698889,
+ "std": 0.015486,
+ "median": 0.691667,
+ "iqr": 0.014167,
+ "ci95_t": 0.03847
+ },
+ "val_loss_stats": {
+ "mean": 0.984541,
+ "std": 0.063092,
+ "median": 0.973807,
+ "iqr": 0.062403,
+ "ci95_t": 0.156731
+ },
+ "fit_time_stats": {
+ "mean": 3.0968,
+ "std": 0.364133,
+ "median": 3.180596,
+ "iqr": 0.356829,
+ "ci95_t": 0.904567
+ }
+ },
+ "constriction_c205_canonical": {
+ "method": "constriction",
+ "candidate_label": "constriction_c205_canonical",
+ "val_accs": [
+ 0.6933333277702332,
+ 0.6866666674613953,
+ 0.746666669845581
+ ],
+ "val_losses": [
+ 1.0619410276412964,
+ 1.016150712966919,
+ 0.8751127123832703
+ ],
+ "fit_times": [
+ 3.237764042103663,
+ 2.7161605830769986,
+ 2.968678707955405
+ ],
+ "val_acc_stats": {
+ "mean": 0.708889,
+ "std": 0.032886,
+ "median": 0.693333,
+ "iqr": 0.03,
+ "ci95_t": 0.081694
+ },
+ "val_loss_stats": {
+ "mean": 0.984401,
+ "std": 0.097377,
+ "median": 1.016151,
+ "iqr": 0.093414,
+ "ci95_t": 0.2419
+ },
+ "fit_time_stats": {
+ "mean": 2.974201,
+ "std": 0.260846,
+ "median": 2.968679,
+ "iqr": 0.260802,
+ "ci95_t": 0.647983
+ }
+ },
+ "constriction_c205_tuned": {
+ "method": "constriction",
+ "candidate_label": "constriction_c205_tuned",
+ "val_accs": [
+ 0.699999988079071,
+ 0.7116666436195374,
+ 0.7133333086967468
+ ],
+ "val_losses": [
+ 0.991266667842865,
+ 0.9303705096244812,
+ 0.9846652150154114
+ ],
+ "fit_times": [
+ 3.042221749899909,
+ 2.8448961251415312,
+ 3.1848887908272445
+ ],
+ "val_acc_stats": {
+ "mean": 0.708333,
+ "std": 0.007265,
+ "median": 0.711667,
+ "iqr": 0.006667,
+ "ci95_t": 0.018047
+ },
+ "val_loss_stats": {
+ "mean": 0.968767,
+ "std": 0.033416,
+ "median": 0.984665,
+ "iqr": 0.030448,
+ "ci95_t": 0.083011
+ },
+ "fit_time_stats": {
+ "mean": 3.024002,
+ "std": 0.170727,
+ "median": 3.042222,
+ "iqr": 0.169996,
+ "ci95_t": 0.424114
+ }
+ },
+ "constriction_c250": {
+ "method": "constriction",
+ "candidate_label": "constriction_c250",
+ "val_accs": [
+ 0.18666666746139526,
+ 0.2150000035762787,
+ 0.20499999821186066
+ ],
+ "val_losses": [
+ 2.250452756881714,
+ 2.2187206745147705,
+ 2.178219795227051
+ ],
+ "fit_times": [
+ 2.9961123750545084,
+ 3.024313250090927,
+ 2.961929291021079
+ ],
+ "val_acc_stats": {
+ "mean": 0.202222,
+ "std": 0.014369,
+ "median": 0.205,
+ "iqr": 0.014167,
+ "ci95_t": 0.035696
+ },
+ "val_loss_stats": {
+ "mean": 2.215798,
+ "std": 0.036205,
+ "median": 2.218721,
+ "iqr": 0.036116,
+ "ci95_t": 0.089939
+ },
+ "fit_time_stats": {
+ "mean": 2.994118,
+ "std": 0.03124,
+ "median": 2.996112,
+ "iqr": 0.031192,
+ "ci95_t": 0.077605
+ }
+ },
+ "constriction_asymmetric": {
+ "method": "constriction",
+ "candidate_label": "constriction_asymmetric",
+ "val_accs": [
+ 0.6316666603088379,
+ 0.5883333086967468,
+ 0.6200000047683716
+ ],
+ "val_losses": [
+ 1.2170491218566895,
+ 1.2684078216552734,
+ 1.2376829385757446
+ ],
+ "fit_times": [
+ 3.023697500117123,
+ 2.8057189998216927,
+ 2.709051915910095
+ ],
+ "val_acc_stats": {
+ "mean": 0.613333,
+ "std": 0.022423,
+ "median": 0.62,
+ "iqr": 0.021667,
+ "ci95_t": 0.055702
+ },
+ "val_loss_stats": {
+ "mean": 1.241047,
+ "std": 0.025844,
+ "median": 1.237683,
+ "iqr": 0.025679,
+ "ci95_t": 0.064201
+ },
+ "fit_time_stats": {
+ "mean": 2.846156,
+ "std": 0.161173,
+ "median": 2.805719,
+ "iqr": 0.157323,
+ "ci95_t": 0.400381
+ }
+ },
+ "local_best_r1_constant": {
+ "method": "local_best",
+ "candidate_label": "local_best_r1_constant",
+ "val_accs": [
+ 0.528333306312561,
+ 0.5333333611488342,
+ 0.5366666913032532
+ ],
+ "val_losses": [
+ 1.4319947957992554,
+ 1.4473850727081299,
+ 1.5045198202133179
+ ],
+ "fit_times": [
+ 2.6544057081919163,
+ 2.7407990000210702,
+ 2.693694499786943
+ ],
+ "val_acc_stats": {
+ "mean": 0.532778,
+ "std": 0.004194,
+ "median": 0.533333,
+ "iqr": 0.004167,
+ "ci95_t": 0.01042
+ },
+ "val_loss_stats": {
+ "mean": 1.4613,
+ "std": 0.038212,
+ "median": 1.447385,
+ "iqr": 0.036263,
+ "ci95_t": 0.094926
+ },
+ "fit_time_stats": {
+ "mean": 2.6963,
+ "std": 0.043256,
+ "median": 2.693694,
+ "iqr": 0.043197,
+ "ci95_t": 0.107454
+ }
+ },
+ "local_best_r2_constant": {
+ "method": "local_best",
+ "candidate_label": "local_best_r2_constant",
+ "val_accs": [
+ 0.628333330154419,
+ 0.6700000166893005,
+ 0.6516666412353516
+ ],
+ "val_losses": [
+ 1.191932201385498,
+ 1.1325551271438599,
+ 1.2125868797302246
+ ],
+ "fit_times": [
+ 2.4563205409795046,
+ 2.5833707919809967,
+ 2.475700625218451
+ ],
+ "val_acc_stats": {
+ "mean": 0.65,
+ "std": 0.020883,
+ "median": 0.651667,
+ "iqr": 0.020833,
+ "ci95_t": 0.051878
+ },
+ "val_loss_stats": {
+ "mean": 1.179025,
+ "std": 0.041548,
+ "median": 1.191932,
+ "iqr": 0.040016,
+ "ci95_t": 0.103212
+ },
+ "fit_time_stats": {
+ "mean": 2.505131,
+ "std": 0.068447,
+ "median": 2.475701,
+ "iqr": 0.063525,
+ "ci95_t": 0.170034
+ }
+ },
+ "local_best_r4_constant": {
+ "method": "local_best",
+ "candidate_label": "local_best_r4_constant",
+ "val_accs": [
+ 0.699999988079071,
+ 0.7283333539962769,
+ 0.7450000047683716
+ ],
+ "val_losses": [
+ 1.0000126361846924,
+ 0.9295963644981384,
+ 0.9051287770271301
+ ],
+ "fit_times": [
+ 2.4682277080137283,
+ 2.4259307920001447,
+ 2.4171505419071764
+ ],
+ "val_acc_stats": {
+ "mean": 0.724444,
+ "std": 0.022751,
+ "median": 0.728333,
+ "iqr": 0.0225,
+ "ci95_t": 0.056516
+ },
+ "val_loss_stats": {
+ "mean": 0.944913,
+ "std": 0.049261,
+ "median": 0.929596,
+ "iqr": 0.047442,
+ "ci95_t": 0.122373
+ },
+ "fit_time_stats": {
+ "mean": 2.437103,
+ "std": 0.02731,
+ "median": 2.425931,
+ "iqr": 0.025539,
+ "ci95_t": 0.067842
+ }
+ },
+ "local_best_r1_decay": {
+ "method": "local_best",
+ "candidate_label": "local_best_r1_decay",
+ "val_accs": [
+ 0.5400000214576721,
+ 0.5733333230018616,
+ 0.5416666865348816
+ ],
+ "val_losses": [
+ 1.4867504835128784,
+ 1.4699759483337402,
+ 1.4344968795776367
+ ],
+ "fit_times": [
+ 2.455931582953781,
+ 2.5800107079558074,
+ 2.5192452499177307
+ ],
+ "val_acc_stats": {
+ "mean": 0.551667,
+ "std": 0.018782,
+ "median": 0.541667,
+ "iqr": 0.016667,
+ "ci95_t": 0.046658
+ },
+ "val_loss_stats": {
+ "mean": 1.463741,
+ "std": 0.026679,
+ "median": 1.469976,
+ "iqr": 0.026127,
+ "ci95_t": 0.066275
+ },
+ "fit_time_stats": {
+ "mean": 2.518396,
+ "std": 0.062044,
+ "median": 2.519245,
+ "iqr": 0.06204,
+ "ci95_t": 0.154127
+ }
+ },
+ "quantum_beta_0.5_1.0": {
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.5_1.0",
+ "val_accs": [
+ 0.5183333158493042,
+ 0.5383333563804626,
+ 0.574999988079071
+ ],
+ "val_losses": [
+ 1.4257338047027588,
+ 1.3660792112350464,
+ 1.295978307723999
+ ],
+ "fit_times": [
+ 2.411743083037436,
+ 2.398069208022207,
+ 2.4090406668838114
+ ],
+ "val_acc_stats": {
+ "mean": 0.543889,
+ "std": 0.028739,
+ "median": 0.538333,
+ "iqr": 0.028333,
+ "ci95_t": 0.071392
+ },
+ "val_loss_stats": {
+ "mean": 1.362597,
+ "std": 0.064948,
+ "median": 1.366079,
+ "iqr": 0.064878,
+ "ci95_t": 0.161341
+ },
+ "fit_time_stats": {
+ "mean": 2.406284,
+ "std": 0.007242,
+ "median": 2.409041,
+ "iqr": 0.006837,
+ "ci95_t": 0.01799
+ }
+ },
+ "quantum_beta_0.6_1.0": {
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.6_1.0",
+ "val_accs": [
+ 0.4050000011920929,
+ 0.3866666555404663,
+ 0.4399999976158142
+ ],
+ "val_losses": [
+ 1.7316218614578247,
+ 1.7482523918151855,
+ 1.684290885925293
+ ],
+ "fit_times": [
+ 2.4751413341145962,
+ 2.41624170797877,
+ 2.4244089999701828
+ ],
+ "val_acc_stats": {
+ "mean": 0.410556,
+ "std": 0.027097,
+ "median": 0.405,
+ "iqr": 0.026667,
+ "ci95_t": 0.067314
+ },
+ "val_loss_stats": {
+ "mean": 1.721388,
+ "std": 0.033186,
+ "median": 1.731622,
+ "iqr": 0.031981,
+ "ci95_t": 0.08244
+ },
+ "fit_time_stats": {
+ "mean": 2.438597,
+ "std": 0.03191,
+ "median": 2.424409,
+ "iqr": 0.02945,
+ "ci95_t": 0.079271
+ }
+ },
+ "quantum_beta_0.5_1.2": {
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.5_1.2",
+ "val_accs": [
+ 0.43833333253860474,
+ 0.5133333206176758,
+ 0.3916666805744171
+ ],
+ "val_losses": [
+ 1.6313401460647583,
+ 1.515285849571228,
+ 1.7098183631896973
+ ],
+ "fit_times": [
+ 2.379183917073533,
+ 2.3730562501586974,
+ 2.438973000040278
+ ],
+ "val_acc_stats": {
+ "mean": 0.447778,
+ "std": 0.061381,
+ "median": 0.438333,
+ "iqr": 0.060833,
+ "ci95_t": 0.15248
+ },
+ "val_loss_stats": {
+ "mean": 1.618815,
+ "std": 0.097869,
+ "median": 1.63134,
+ "iqr": 0.097266,
+ "ci95_t": 0.243123
+ },
+ "fit_time_stats": {
+ "mean": 2.397071,
+ "std": 0.036417,
+ "median": 2.379184,
+ "iqr": 0.032958,
+ "ci95_t": 0.090466
+ }
+ },
+ "quantum_beta_0.4_0.9": {
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.4_0.9",
+ "val_accs": [
+ 0.5433333516120911,
+ 0.5716666579246521,
+ 0.5799999833106995
+ ],
+ "val_losses": [
+ 1.369968295097351,
+ 1.3982360363006592,
+ 1.244922161102295
+ ],
+ "fit_times": [
+ 2.5881015001796186,
+ 2.5672016669996083,
+ 2.4583064999897033
+ ],
+ "val_acc_stats": {
+ "mean": 0.565,
+ "std": 0.019221,
+ "median": 0.571667,
+ "iqr": 0.018333,
+ "ci95_t": 0.047748
+ },
+ "val_loss_stats": {
+ "mean": 1.337709,
+ "std": 0.081589,
+ "median": 1.369968,
+ "iqr": 0.076657,
+ "ci95_t": 0.202681
+ },
+ "fit_time_stats": {
+ "mean": 2.53787,
+ "std": 0.069692,
+ "median": 2.567202,
+ "iqr": 0.064898,
+ "ci95_t": 0.173126
+ }
+ }
+ },
+ "confirmation": {
+ "adaptive_moment": {
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "test_accs": [
+ 0.5960000157356262,
+ 0.6150000095367432,
+ 0.6190000176429749,
+ 0.6150000095367432,
+ 0.6079999804496765
+ ],
+ "test_losses": [
+ 1.2476433515548706,
+ 1.2172735929489136,
+ 1.2344101667404175,
+ 1.1978241205215454,
+ 1.2509828805923462
+ ],
+ "fit_times": [
+ 3.3018275420181453,
+ 3.082969541894272,
+ 2.7472599998582155,
+ 2.670909541891888,
+ 2.9130489169619977
+ ],
+ "test_acc_stats": {
+ "mean": 0.6106,
+ "std": 0.009072,
+ "median": 0.615,
+ "iqr": 0.007,
+ "ci95_t": 0.011264
+ },
+ "test_loss_stats": {
+ "mean": 1.229627,
+ "std": 0.022179,
+ "median": 1.23441,
+ "iqr": 0.03037,
+ "ci95_t": 0.027538
+ },
+ "fit_time_stats": {
+ "mean": 2.943203,
+ "std": 0.255731,
+ "median": 2.913049,
+ "iqr": 0.33571,
+ "ci95_t": 0.317527
+ }
+ },
+ "inertia": {
+ "method": "inertia",
+ "candidate_label": "inertia_asymmetric",
+ "test_accs": [
+ 0.6320000290870667,
+ 0.578000009059906,
+ 0.6620000004768372,
+ 0.621999979019165,
+ 0.6209999918937683
+ ],
+ "test_losses": [
+ 1.2075469493865967,
+ 1.2740414142608643,
+ 1.0797629356384277,
+ 1.2426005601882935,
+ 1.2609055042266846
+ ],
+ "fit_times": [
+ 2.564156916923821,
+ 2.5913295838981867,
+ 2.6188287080731243,
+ 2.534188667079434,
+ 2.542070833966136
+ ],
+ "test_acc_stats": {
+ "mean": 0.623,
+ "std": 0.030133,
+ "median": 0.622,
+ "iqr": 0.011,
+ "ci95_t": 0.037415
+ },
+ "test_loss_stats": {
+ "mean": 1.212971,
+ "std": 0.078548,
+ "median": 1.242601,
+ "iqr": 0.053359,
+ "ci95_t": 0.097528
+ },
+ "fit_time_stats": {
+ "mean": 2.570115,
+ "std": 0.035127,
+ "median": 2.564157,
+ "iqr": 0.049259,
+ "ci95_t": 0.043616
+ }
+ },
+ "constriction": {
+ "method": "constriction",
+ "candidate_label": "constriction_c205_canonical",
+ "test_accs": [
+ 0.6299999952316284,
+ 0.5849999785423279,
+ 0.5789999961853027,
+ 0.6179999709129333,
+ 0.6209999918937683
+ ],
+ "test_losses": [
+ 1.2035431861877441,
+ 1.3196481466293335,
+ 1.2498247623443604,
+ 1.2384077310562134,
+ 1.219950795173645
+ ],
+ "fit_times": [
+ 2.5165979999583215,
+ 2.481917541939765,
+ 2.593008500058204,
+ 2.4862103750929236,
+ 2.5256920421961695
+ ],
+ "test_acc_stats": {
+ "mean": 0.6066,
+ "std": 0.022985,
+ "median": 0.618,
+ "iqr": 0.036,
+ "ci95_t": 0.028539
+ },
+ "test_loss_stats": {
+ "mean": 1.246275,
+ "std": 0.044657,
+ "median": 1.238408,
+ "iqr": 0.029874,
+ "ci95_t": 0.055448
+ },
+ "fit_time_stats": {
+ "mean": 2.520685,
+ "std": 0.04462,
+ "median": 2.516598,
+ "iqr": 0.039482,
+ "ci95_t": 0.055402
+ }
+ },
+ "local_best": {
+ "method": "local_best",
+ "candidate_label": "local_best_r4_constant",
+ "test_accs": [
+ 0.6549999713897705,
+ 0.593999981880188,
+ 0.6570000052452087,
+ 0.625,
+ 0.6010000109672546
+ ],
+ "test_losses": [
+ 1.1751943826675415,
+ 1.2656233310699463,
+ 1.167758584022522,
+ 1.1620168685913086,
+ 1.286249041557312
+ ],
+ "fit_times": [
+ 2.535716458922252,
+ 2.5843862500041723,
+ 2.485073500080034,
+ 2.467889874940738,
+ 2.488020292017609
+ ],
+ "test_acc_stats": {
+ "mean": 0.6264,
+ "std": 0.029373,
+ "median": 0.625,
+ "iqr": 0.054,
+ "ci95_t": 0.036471
+ },
+ "test_loss_stats": {
+ "mean": 1.211368,
+ "std": 0.059575,
+ "median": 1.175194,
+ "iqr": 0.097865,
+ "ci95_t": 0.073971
+ },
+ "fit_time_stats": {
+ "mean": 2.512217,
+ "std": 0.04756,
+ "median": 2.48802,
+ "iqr": 0.050643,
+ "ci95_t": 0.059052
+ }
+ },
+ "quantum": {
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.4_0.9",
+ "test_accs": [
+ 0.5320000052452087,
+ 0.4650000035762787,
+ 0.4860000014305115,
+ 0.46799999475479126,
+ 0.4779999852180481
+ ],
+ "test_losses": [
+ 1.464557409286499,
+ 1.5834708213806152,
+ 1.5065674781799316,
+ 1.4775264263153076,
+ 1.5641074180603027
+ ],
+ "fit_times": [
+ 2.3820620418991894,
+ 2.4394417498260736,
+ 2.3948492500931025,
+ 2.3948124169837683,
+ 2.402772541856393
+ ],
+ "test_acc_stats": {
+ "mean": 0.4858,
+ "std": 0.027133,
+ "median": 0.478,
+ "iqr": 0.018,
+ "ci95_t": 0.03369
+ },
+ "test_loss_stats": {
+ "mean": 1.519246,
+ "std": 0.052511,
+ "median": 1.506567,
+ "iqr": 0.086581,
+ "ci95_t": 0.0652
+ },
+ "fit_time_stats": {
+ "mean": 2.402788,
+ "std": 0.021793,
+ "median": 2.394849,
+ "iqr": 0.00796,
+ "ci95_t": 0.027059
+ }
+ }
+ },
+ "scaling": {
+ "30p_80e_fixed_epoch": {
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "regimen": "fixed_epoch",
+ "test_accs": [
+ 0.5789999961853027,
+ 0.6060000061988831,
+ 0.6389999985694885,
+ 0.6589999794960022,
+ 0.6230000257492065
+ ],
+ "test_losses": [
+ 1.2778329849243164,
+ 1.199388861656189,
+ 1.1562552452087402,
+ 1.0667707920074463,
+ 1.2670954465866089
+ ],
+ "fit_times": [
+ 2.591740084113553,
+ 2.7087553329765797,
+ 2.6669440830592066,
+ 2.6316912909969687,
+ 2.8266918330918998
+ ],
+ "test_acc_stats": {
+ "mean": 0.6212,
+ "std": 0.030663,
+ "median": 0.623,
+ "iqr": 0.033,
+ "ci95_t": 0.038072
+ },
+ "test_loss_stats": {
+ "mean": 1.193469,
+ "std": 0.086618,
+ "median": 1.199389,
+ "iqr": 0.11084,
+ "ci95_t": 0.107548
+ },
+ "fit_time_stats": {
+ "mean": 2.685165,
+ "std": 0.090147,
+ "median": 2.666944,
+ "iqr": 0.077064,
+ "ci95_t": 0.111931
+ }
+ },
+ "60p_80e_fixed_epoch": {
+ "n_particles": 60,
+ "epochs": 80,
+ "particle_epochs": 4800,
+ "regimen": "fixed_epoch",
+ "test_accs": [
+ 0.6729999780654907,
+ 0.6499999761581421,
+ 0.6589999794960022,
+ 0.6610000133514404,
+ 0.6539999842643738
+ ],
+ "test_losses": [
+ 1.021918535232544,
+ 1.1486669778823853,
+ 1.059795618057251,
+ 1.0703872442245483,
+ 1.0723776817321777
+ ],
+ "fit_times": [
+ 6.297774499980733,
+ 5.944013542030007,
+ 5.409191000042483,
+ 5.092122667003423,
+ 5.18646250013262
+ ],
+ "test_acc_stats": {
+ "mean": 0.6594,
+ "std": 0.008735,
+ "median": 0.659,
+ "iqr": 0.007,
+ "ci95_t": 0.010846
+ },
+ "test_loss_stats": {
+ "mean": 1.074629,
+ "std": 0.046106,
+ "median": 1.070387,
+ "iqr": 0.012582,
+ "ci95_t": 0.057247
+ },
+ "fit_time_stats": {
+ "mean": 5.585913,
+ "std": 0.517108,
+ "median": 5.409191,
+ "iqr": 0.757551,
+ "ci95_t": 0.642064
+ }
+ },
+ "90p_80e_fixed_epoch": {
+ "n_particles": 90,
+ "epochs": 80,
+ "particle_epochs": 7200,
+ "regimen": "fixed_epoch",
+ "test_accs": [
+ 0.7310000061988831,
+ 0.718999981880188,
+ 0.6959999799728394,
+ 0.6769999861717224,
+ 0.6930000185966492
+ ],
+ "test_losses": [
+ 0.8688502311706543,
+ 0.9239839911460876,
+ 0.9498289227485657,
+ 0.954045295715332,
+ 0.962693989276886
+ ],
+ "fit_times": [
+ 8.216789624886587,
+ 8.96910895803012,
+ 9.117825584020466,
+ 8.722332582809031,
+ 8.110321166925132
+ ],
+ "test_acc_stats": {
+ "mean": 0.7032,
+ "std": 0.021592,
+ "median": 0.696,
+ "iqr": 0.026,
+ "ci95_t": 0.026809
+ },
+ "test_loss_stats": {
+ "mean": 0.93188,
+ "std": 0.038073,
+ "median": 0.949829,
+ "iqr": 0.030061,
+ "ci95_t": 0.047273
+ },
+ "fit_time_stats": {
+ "mean": 8.627276,
+ "std": 0.447846,
+ "median": 8.722333,
+ "iqr": 0.752319,
+ "ci95_t": 0.556066
+ }
+ },
+ "120p_80e_fixed_epoch": {
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "regimen": "fixed_epoch",
+ "test_accs": [
+ 0.7360000014305115,
+ 0.7239999771118164,
+ 0.6919999718666077,
+ 0.7350000143051147,
+ 0.7300000190734863
+ ],
+ "test_losses": [
+ 0.8584634065628052,
+ 0.9025362133979797,
+ 1.001193642616272,
+ 0.8601324558258057,
+ 0.889915406703949
+ ],
+ "fit_times": [
+ 11.962705624988303,
+ 11.906837583053857,
+ 10.664651792030782,
+ 10.921957665821537,
+ 10.411899874918163
+ ],
+ "test_acc_stats": {
+ "mean": 0.7234,
+ "std": 0.018188,
+ "median": 0.73,
+ "iqr": 0.011,
+ "ci95_t": 0.022583
+ },
+ "test_loss_stats": {
+ "mean": 0.902448,
+ "std": 0.05838,
+ "median": 0.889915,
+ "iqr": 0.042404,
+ "ci95_t": 0.072488
+ },
+ "fit_time_stats": {
+ "mean": 11.173611,
+ "std": 0.718134,
+ "median": 10.921958,
+ "iqr": 1.242186,
+ "ci95_t": 0.891666
+ }
+ },
+ "30p_80e_fixed_budget": {
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "regimen": "fixed_budget",
+ "test_accs": [
+ 0.5789999961853027,
+ 0.6060000061988831,
+ 0.6389999985694885,
+ 0.6589999794960022,
+ 0.6230000257492065
+ ],
+ "test_losses": [
+ 1.2778329849243164,
+ 1.199388861656189,
+ 1.1562552452087402,
+ 1.0667707920074463,
+ 1.2670954465866089
+ ],
+ "fit_times": [
+ 2.591740084113553,
+ 2.7087553329765797,
+ 2.6669440830592066,
+ 2.6316912909969687,
+ 2.8266918330918998
+ ],
+ "test_acc_stats": {
+ "mean": 0.6212,
+ "std": 0.030663,
+ "median": 0.623,
+ "iqr": 0.033,
+ "ci95_t": 0.038072
+ },
+ "test_loss_stats": {
+ "mean": 1.193469,
+ "std": 0.086618,
+ "median": 1.199389,
+ "iqr": 0.11084,
+ "ci95_t": 0.107548
+ },
+ "fit_time_stats": {
+ "mean": 2.685165,
+ "std": 0.090147,
+ "median": 2.666944,
+ "iqr": 0.077064,
+ "ci95_t": 0.111931
+ }
+ },
+ "60p_40e_fixed_budget": {
+ "n_particles": 60,
+ "epochs": 40,
+ "particle_epochs": 2400,
+ "regimen": "fixed_budget",
+ "test_accs": [
+ 0.49000000953674316,
+ 0.5270000100135803,
+ 0.5109999775886536,
+ 0.5370000004768372,
+ 0.47200000286102295
+ ],
+ "test_losses": [
+ 1.5396113395690918,
+ 1.564630150794983,
+ 1.4340611696243286,
+ 1.4914799928665161,
+ 1.6433888673782349
+ ],
+ "fit_times": [
+ 2.6427467500325292,
+ 2.897082625189796,
+ 2.8362932079471648,
+ 2.7601085831411183,
+ 2.791566374944523
+ ],
+ "test_acc_stats": {
+ "mean": 0.5074,
+ "std": 0.026595,
+ "median": 0.511,
+ "iqr": 0.037,
+ "ci95_t": 0.033022
+ },
+ "test_loss_stats": {
+ "mean": 1.534634,
+ "std": 0.078628,
+ "median": 1.539611,
+ "iqr": 0.07315,
+ "ci95_t": 0.097628
+ },
+ "fit_time_stats": {
+ "mean": 2.78556,
+ "std": 0.094988,
+ "median": 2.791566,
+ "iqr": 0.076185,
+ "ci95_t": 0.117941
+ }
+ },
+ "90p_27e_fixed_budget": {
+ "n_particles": 90,
+ "epochs": 27,
+ "particle_epochs": 2430,
+ "regimen": "fixed_budget",
+ "test_accs": [
+ 0.40400001406669617,
+ 0.5180000066757202,
+ 0.4180000126361847,
+ 0.5059999823570251,
+ 0.5450000166893005
+ ],
+ "test_losses": [
+ 1.7139235734939575,
+ 1.525922417640686,
+ 1.7064924240112305,
+ 1.6065630912780762,
+ 1.5009552240371704
+ ],
+ "fit_times": [
+ 3.001450875075534,
+ 2.9281624578870833,
+ 3.446030291961506,
+ 3.13685941696167,
+ 3.0350140419322997
+ ],
+ "test_acc_stats": {
+ "mean": 0.4782,
+ "std": 0.063144,
+ "median": 0.506,
+ "iqr": 0.1,
+ "ci95_t": 0.078403
+ },
+ "test_loss_stats": {
+ "mean": 1.610771,
+ "std": 0.098843,
+ "median": 1.606563,
+ "iqr": 0.18057,
+ "ci95_t": 0.122727
+ },
+ "fit_time_stats": {
+ "mean": 3.109503,
+ "std": 0.202551,
+ "median": 3.035014,
+ "iqr": 0.135409,
+ "ci95_t": 0.251496
+ }
+ },
+ "120p_20e_fixed_budget": {
+ "n_particles": 120,
+ "epochs": 20,
+ "particle_epochs": 2400,
+ "regimen": "fixed_budget",
+ "test_accs": [
+ 0.43799999356269836,
+ 0.4099999964237213,
+ 0.375,
+ 0.42399999499320984,
+ 0.4059999883174896
+ ],
+ "test_losses": [
+ 1.7100492715835571,
+ 1.8141505718231201,
+ 1.8838708400726318,
+ 1.7434691190719604,
+ 1.8486356735229492
+ ],
+ "fit_times": [
+ 3.14462749985978,
+ 3.102293625008315,
+ 2.7550693340599537,
+ 2.9445771670434624,
+ 3.1960245410446078
+ ],
+ "test_acc_stats": {
+ "mean": 0.4106,
+ "std": 0.023554,
+ "median": 0.41,
+ "iqr": 0.018,
+ "ci95_t": 0.029246
+ },
+ "test_loss_stats": {
+ "mean": 1.800035,
+ "std": 0.072261,
+ "median": 1.814151,
+ "iqr": 0.105167,
+ "ci95_t": 0.089723
+ },
+ "fit_time_stats": {
+ "mean": 3.028518,
+ "std": 0.179446,
+ "median": 3.102294,
+ "iqr": 0.20005,
+ "ci95_t": 0.222808
+ }
+ }
+ }
+ },
+ "search_runs": [
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s0.5",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.112807035446167,
+ "train_acc": 0.6570000052452087,
+ "train_mse": 0.047893233597278595,
+ "val_loss": 1.0964455604553223,
+ "val_acc": 0.6633333563804626,
+ "val_mse": 0.046677425503730774,
+ "fit_time_sec": 2.5230953749269247,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.03,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.03,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.03_s0.5_seed51_9254335e5dae"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s0.5",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.995387077331543,
+ "train_acc": 0.6869999766349792,
+ "train_mse": 0.04287662357091904,
+ "val_loss": 1.0115970373153687,
+ "val_acc": 0.6816666722297668,
+ "val_mse": 0.04280940815806389,
+ "fit_time_sec": 2.5447300830855966,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.03,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.03,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.03_s0.5_seed52_e4bbd852449a"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s0.5",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9480092525482178,
+ "train_acc": 0.7080000042915344,
+ "train_mse": 0.04147067293524742,
+ "val_loss": 0.9940392971038818,
+ "val_acc": 0.6883333325386047,
+ "val_mse": 0.0421285405755043,
+ "fit_time_sec": 2.493663167115301,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.03,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.03,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.03_s0.5_seed53_18947a425931"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s1.0",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9984938502311707,
+ "train_acc": 0.7024999856948853,
+ "train_mse": 0.04213668778538704,
+ "val_loss": 1.0240328311920166,
+ "val_acc": 0.6850000023841858,
+ "val_mse": 0.04404553398489952,
+ "fit_time_sec": 2.54264641716145,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.03,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.03,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.03_s1.0_seed51_4406d9e39cd3"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s1.0",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0163198709487915,
+ "train_acc": 0.6890000104904175,
+ "train_mse": 0.04318585619330406,
+ "val_loss": 0.9720749855041504,
+ "val_acc": 0.6933333277702332,
+ "val_mse": 0.042471032589673996,
+ "fit_time_sec": 2.491340707987547,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.03,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.03,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.03_s1.0_seed52_a6f227e4f325"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s1.0",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0211265087127686,
+ "train_acc": 0.6884999871253967,
+ "train_mse": 0.04335062578320503,
+ "val_loss": 1.081996202468872,
+ "val_acc": 0.6850000023841858,
+ "val_mse": 0.04483034089207649,
+ "fit_time_sec": 2.633713499875739,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.03,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.03,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.03_s1.0_seed53_6ee91380448d"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s1.5",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0612047910690308,
+ "train_acc": 0.6735000014305115,
+ "train_mse": 0.045148931443691254,
+ "val_loss": 1.030881404876709,
+ "val_acc": 0.6850000023841858,
+ "val_mse": 0.04405777156352997,
+ "fit_time_sec": 2.8367540831677616,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.03,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.03,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.03_s1.5_seed51_d642db13db97"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s1.5",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9462777972221375,
+ "train_acc": 0.7149999737739563,
+ "train_mse": 0.040491439402103424,
+ "val_loss": 0.8990310430526733,
+ "val_acc": 0.7266666889190674,
+ "val_mse": 0.03923330828547478,
+ "fit_time_sec": 2.5477614579722285,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.03,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.03,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.03_s1.5_seed52_f51da30cd8ee"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.03_s1.5",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9608960747718811,
+ "train_acc": 0.7120000123977661,
+ "train_mse": 0.04050719365477562,
+ "val_loss": 1.0034033060073853,
+ "val_acc": 0.6833333373069763,
+ "val_mse": 0.042279649525880814,
+ "fit_time_sec": 2.5643632498104125,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.03,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.03,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.03_s1.5_seed53_fa090ba145a2"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.068866491317749,
+ "train_acc": 0.6855000257492065,
+ "train_mse": 0.04453761503100395,
+ "val_loss": 1.0220483541488647,
+ "val_acc": 0.675000011920929,
+ "val_mse": 0.04446922242641449,
+ "fit_time_sec": 2.6285997920203954,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s0.5_seed51_365f7032facd"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9650915265083313,
+ "train_acc": 0.7080000042915344,
+ "train_mse": 0.041975654661655426,
+ "val_loss": 0.9152445197105408,
+ "val_acc": 0.7083333134651184,
+ "val_mse": 0.04066821560263634,
+ "fit_time_sec": 2.7918378338217735,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s0.5_seed52_dd0ab4e7cbad"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9414446949958801,
+ "train_acc": 0.7014999985694885,
+ "train_mse": 0.04160618409514427,
+ "val_loss": 0.9156243801116943,
+ "val_acc": 0.721666693687439,
+ "val_mse": 0.03982962667942047,
+ "fit_time_sec": 2.729898874880746,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s0.5_seed53_99620b39a997"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0662047863006592,
+ "train_acc": 0.6754999756813049,
+ "train_mse": 0.04559904336929321,
+ "val_loss": 0.9721739888191223,
+ "val_acc": 0.6899999976158142,
+ "val_mse": 0.042344048619270325,
+ "fit_time_sec": 2.5812953328713775,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.0_seed51_bc8c753c2952"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9808334112167358,
+ "train_acc": 0.6924999952316284,
+ "train_mse": 0.04274387285113335,
+ "val_loss": 0.9488086104393005,
+ "val_acc": 0.6933333277702332,
+ "val_mse": 0.04174558073282242,
+ "fit_time_sec": 2.8018474159762263,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.0_seed52_a7ac346e728f"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9464473724365234,
+ "train_acc": 0.7085000276565552,
+ "train_mse": 0.041684526950120926,
+ "val_loss": 0.9320653080940247,
+ "val_acc": 0.7083333134651184,
+ "val_mse": 0.040938157588243484,
+ "fit_time_sec": 2.7171109160408378,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.0_seed53_78a13f84d0fd"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.5",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.1136488914489746,
+ "train_acc": 0.6549999713897705,
+ "train_mse": 0.047874581068754196,
+ "val_loss": 1.1235008239746094,
+ "val_acc": 0.6650000214576721,
+ "val_mse": 0.04781530797481537,
+ "fit_time_sec": 2.7500752080231905,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.5_seed51_e0a8bfba3fd8"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.5",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0324392318725586,
+ "train_acc": 0.6825000047683716,
+ "train_mse": 0.04490217566490173,
+ "val_loss": 1.0213521718978882,
+ "val_acc": 0.6833333373069763,
+ "val_mse": 0.04513593390583992,
+ "fit_time_sec": 3.103288209065795,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.5_seed52_0b9e4870ea8e"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.5",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0860146284103394,
+ "train_acc": 0.6589999794960022,
+ "train_mse": 0.045827291905879974,
+ "val_loss": 1.0920277833938599,
+ "val_acc": 0.6499999761581421,
+ "val_mse": 0.04753243178129196,
+ "fit_time_sec": 2.862214791122824,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.5_seed53_1726833a0ed7"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s0.5",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0369712114334106,
+ "train_acc": 0.6644999980926514,
+ "train_mse": 0.045163437724113464,
+ "val_loss": 1.0877516269683838,
+ "val_acc": 0.6766666769981384,
+ "val_mse": 0.04590357467532158,
+ "fit_time_sec": 2.8528131251223385,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.1,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.1_s0.5_seed51_0df94b884d5b"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s0.5",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9936539530754089,
+ "train_acc": 0.6965000033378601,
+ "train_mse": 0.04206997528672218,
+ "val_loss": 0.9451570510864258,
+ "val_acc": 0.6983333230018616,
+ "val_mse": 0.040929101407527924,
+ "fit_time_sec": 2.7851123749278486,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.1,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.1_s0.5_seed52_f82e72b430c4"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s0.5",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9365023374557495,
+ "train_acc": 0.7014999985694885,
+ "train_mse": 0.040903326123952866,
+ "val_loss": 0.8658249974250793,
+ "val_acc": 0.7283333539962769,
+ "val_mse": 0.038747914135456085,
+ "fit_time_sec": 2.7191387079656124,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.1,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.1_s0.5_seed53_e9335ecdd130"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s1.0",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0722532272338867,
+ "train_acc": 0.6995000243186951,
+ "train_mse": 0.04340146481990814,
+ "val_loss": 0.9926102757453918,
+ "val_acc": 0.7016666531562805,
+ "val_mse": 0.04247405380010605,
+ "fit_time_sec": 2.8380547501146793,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.1,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.1_s1.0_seed51_8d985039d696"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s1.0",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9977437853813171,
+ "train_acc": 0.6930000185966492,
+ "train_mse": 0.04243411496281624,
+ "val_loss": 1.009635329246521,
+ "val_acc": 0.6966666579246521,
+ "val_mse": 0.04288069158792496,
+ "fit_time_sec": 2.905045999912545,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.1,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.1_s1.0_seed52_c1fd755f4fda"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s1.0",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0425642728805542,
+ "train_acc": 0.6664999723434448,
+ "train_mse": 0.04493626207113266,
+ "val_loss": 1.0561128854751587,
+ "val_acc": 0.6783333420753479,
+ "val_mse": 0.0449373684823513,
+ "fit_time_sec": 2.7804793331306428,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.1,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.1_s1.0_seed53_9677f2ddbfea"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s1.5",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0099478960037231,
+ "train_acc": 0.6775000095367432,
+ "train_mse": 0.04376600682735443,
+ "val_loss": 1.00997793674469,
+ "val_acc": 0.6899999976158142,
+ "val_mse": 0.042956266552209854,
+ "fit_time_sec": 2.8892802079208195,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.1,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.1_s1.5_seed51_170eb01a03c4"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s1.5",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0597009658813477,
+ "train_acc": 0.6744999885559082,
+ "train_mse": 0.04503478854894638,
+ "val_loss": 1.063821792602539,
+ "val_acc": 0.6966666579246521,
+ "val_mse": 0.044883932918310165,
+ "fit_time_sec": 2.669369083130732,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.1,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.1_s1.5_seed52_a5da460b0a58"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.1_s1.5",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.986152708530426,
+ "train_acc": 0.7080000042915344,
+ "train_mse": 0.0417320616543293,
+ "val_loss": 1.0491483211517334,
+ "val_acc": 0.6850000023841858,
+ "val_mse": 0.04293783754110336,
+ "fit_time_sec": 2.626303083030507,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.1,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.1,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.1_s1.5_seed53_fdf1e35190cc"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s0.5",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.1084171533584595,
+ "train_acc": 0.652999997138977,
+ "train_mse": 0.048417091369628906,
+ "val_loss": 1.1322306394577026,
+ "val_acc": 0.6600000262260437,
+ "val_mse": 0.04928039386868477,
+ "fit_time_sec": 2.5766194579191506,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.15,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.15,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.15_s0.5_seed51_bf73e336e47b"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s0.5",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.970059335231781,
+ "train_acc": 0.7129999995231628,
+ "train_mse": 0.040026597678661346,
+ "val_loss": 0.9312149882316589,
+ "val_acc": 0.7300000190734863,
+ "val_mse": 0.03986109420657158,
+ "fit_time_sec": 2.731992583023384,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.15,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.15,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.15_s0.5_seed52_0ca83bb626bd"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s0.5",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9970248341560364,
+ "train_acc": 0.6995000243186951,
+ "train_mse": 0.042638134211301804,
+ "val_loss": 0.9656715989112854,
+ "val_acc": 0.70333331823349,
+ "val_mse": 0.04226723685860634,
+ "fit_time_sec": 3.0274115409702063,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.15,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.15,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.15_s0.5_seed53_b4e0353f50d3"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s1.0",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0099536180496216,
+ "train_acc": 0.7009999752044678,
+ "train_mse": 0.04250181466341019,
+ "val_loss": 0.9564719796180725,
+ "val_acc": 0.7166666388511658,
+ "val_mse": 0.04047820717096329,
+ "fit_time_sec": 2.9793542500119656,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.15,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.15,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.15_s1.0_seed51_88a93389d6d1"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s1.0",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0434995889663696,
+ "train_acc": 0.6819999814033508,
+ "train_mse": 0.045114465057849884,
+ "val_loss": 0.9963273406028748,
+ "val_acc": 0.6949999928474426,
+ "val_mse": 0.04349374398589134,
+ "fit_time_sec": 2.8151185419410467,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.15,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.15,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.15_s1.0_seed52_857c4f4a6a86"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s1.0",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0348174571990967,
+ "train_acc": 0.6840000152587891,
+ "train_mse": 0.0439472496509552,
+ "val_loss": 1.0127019882202148,
+ "val_acc": 0.6866666674613953,
+ "val_mse": 0.04363732784986496,
+ "fit_time_sec": 3.0412363330833614,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.15,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.15,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.15_s1.0_seed53_1b76a5f2a720"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s1.5",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.1573493480682373,
+ "train_acc": 0.6299999952316284,
+ "train_mse": 0.04972128942608833,
+ "val_loss": 1.2029211521148682,
+ "val_acc": 0.6133333444595337,
+ "val_mse": 0.05152761936187744,
+ "fit_time_sec": 3.1714885828550905,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.15,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.15,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.15_s1.5_seed51_328b0b0617f5"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s1.5",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.060623288154602,
+ "train_acc": 0.6949999928474426,
+ "train_mse": 0.04253785312175751,
+ "val_loss": 1.0831577777862549,
+ "val_acc": 0.6966666579246521,
+ "val_mse": 0.04344262182712555,
+ "fit_time_sec": 2.993674041936174,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.15,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.15,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.15_s1.5_seed52_b34244a19635"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.15_s1.5",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0753278732299805,
+ "train_acc": 0.6769999861717224,
+ "train_mse": 0.044508710503578186,
+ "val_loss": 0.9602290987968445,
+ "val_acc": 0.6983333230018616,
+ "val_mse": 0.0414869599044323,
+ "fit_time_sec": 2.7658886671997607,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.15,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.15,
+ "moment_step_size": 1.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.15_s1.5_seed53_0b2f2b4a9feb"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0_beta0.8",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.1594665050506592,
+ "train_acc": 0.6480000019073486,
+ "train_mse": 0.04893743246793747,
+ "val_loss": 1.1239941120147705,
+ "val_acc": 0.6700000166893005,
+ "val_mse": 0.047122661024332047,
+ "fit_time_sec": 2.764871333958581,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.8,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.8
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.0_beta0.8_seed51_a7b18877a748"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0_beta0.8",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9945915341377258,
+ "train_acc": 0.7064999938011169,
+ "train_mse": 0.041273947805166245,
+ "val_loss": 1.0324488878250122,
+ "val_acc": 0.6683333516120911,
+ "val_mse": 0.04436164349317551,
+ "fit_time_sec": 2.830462665995583,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.8,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.8
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.0_beta0.8_seed52_3d49224951e5"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0_beta0.8",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9297089576721191,
+ "train_acc": 0.7110000252723694,
+ "train_mse": 0.04138343408703804,
+ "val_loss": 0.938503623008728,
+ "val_acc": 0.70333331823349,
+ "val_mse": 0.04101715609431267,
+ "fit_time_sec": 2.8122877080459148,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.8,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.8
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.0_beta0.8_seed53_dfa6c5fdcb73"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0_beta0.95",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.1143780946731567,
+ "train_acc": 0.6514999866485596,
+ "train_mse": 0.047635458409786224,
+ "val_loss": 1.0093973875045776,
+ "val_acc": 0.6800000071525574,
+ "val_mse": 0.04380199685692787,
+ "fit_time_sec": 2.9217382080387324,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.95,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.95
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.0_beta0.95_seed51_2d4e821de2d9"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0_beta0.95",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0144661664962769,
+ "train_acc": 0.6884999871253967,
+ "train_mse": 0.0433683842420578,
+ "val_loss": 0.9828318357467651,
+ "val_acc": 0.6833333373069763,
+ "val_mse": 0.04375388100743294,
+ "fit_time_sec": 2.777603624854237,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.95,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.95
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.0_beta0.95_seed52_be35e11108b1"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s1.0_beta0.95",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.1004270315170288,
+ "train_acc": 0.6600000262260437,
+ "train_mse": 0.0467742420732975,
+ "val_loss": 1.0834088325500488,
+ "val_acc": 0.6683333516120911,
+ "val_mse": 0.04595582187175751,
+ "fit_time_sec": 3.0502532080281526,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.95,
+ "moment_beta2": 0.999,
+ "moment_step_size": 1.0,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 1.0,
+ "moment_beta1": 0.95
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_am_b0.06_s1.0_beta0.95_seed53_1cddb28ce156"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_canonical",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4416260719299316,
+ "train_acc": 0.5649999976158142,
+ "train_mse": 0.05923965945839882,
+ "val_loss": 1.4125466346740723,
+ "val_acc": 0.6000000238418579,
+ "val_mse": 0.05729174241423607,
+ "fit_time_sec": 3.098805333022028,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.1,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_canonical_seed51_4dc58feffda7"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_canonical",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.665074348449707,
+ "train_acc": 0.4894999861717224,
+ "train_mse": 0.06661199778318405,
+ "val_loss": 1.6294100284576416,
+ "val_acc": 0.5066666603088379,
+ "val_mse": 0.06497763097286224,
+ "fit_time_sec": 2.652766958111897,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.1,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_canonical_seed52_241a50b47d94"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_canonical",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4698249101638794,
+ "train_acc": 0.5565000176429749,
+ "train_mse": 0.060796692967414856,
+ "val_loss": 1.4316622018814087,
+ "val_acc": 0.5683333277702332,
+ "val_mse": 0.059196680784225464,
+ "fit_time_sec": 2.529014667030424,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.1,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_canonical_seed53_ae4cc4a5b7f1"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_tuned",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0468239784240723,
+ "train_acc": 0.699999988079071,
+ "train_mse": 0.043503936380147934,
+ "val_loss": 1.0345858335494995,
+ "val_acc": 0.6816666722297668,
+ "val_mse": 0.04465937986969948,
+ "fit_time_sec": 2.626064541982487,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_tuned_seed51_6834bc3982de"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_tuned",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9420707821846008,
+ "train_acc": 0.703000009059906,
+ "train_mse": 0.04143402725458145,
+ "val_loss": 0.9224241375923157,
+ "val_acc": 0.7250000238418579,
+ "val_mse": 0.040230974555015564,
+ "fit_time_sec": 2.5009557919111103,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_tuned_seed52_6d0b4b7a7865"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_tuned",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0711344480514526,
+ "train_acc": 0.6754999756813049,
+ "train_mse": 0.04559122398495674,
+ "val_loss": 1.0678696632385254,
+ "val_acc": 0.6766666769981384,
+ "val_mse": 0.04436859115958214,
+ "fit_time_sec": 2.4420957090333104,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_tuned_seed53_f07a1778e65d"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_low_w",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.113174319267273,
+ "train_acc": 0.6365000009536743,
+ "train_mse": 0.04887063428759575,
+ "val_loss": 1.0575727224349976,
+ "val_acc": 0.6850000023841858,
+ "val_mse": 0.0461583249270916,
+ "fit_time_sec": 2.484879707917571,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.55,
+ "w_max": 0.55
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.55,
+ "w_max": 0.55,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_low_w_seed51_574275875124"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_low_w",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0245047807693481,
+ "train_acc": 0.6790000200271606,
+ "train_mse": 0.04524479806423187,
+ "val_loss": 0.9806669354438782,
+ "val_acc": 0.70333331823349,
+ "val_mse": 0.042586930096149445,
+ "fit_time_sec": 2.643615792039782,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.55,
+ "w_max": 0.55
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.55,
+ "w_max": 0.55,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_low_w_seed52_e6cccf2d56fb"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_low_w",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0131726264953613,
+ "train_acc": 0.6859999895095825,
+ "train_mse": 0.04427120089530945,
+ "val_loss": 0.9656168818473816,
+ "val_acc": 0.6983333230018616,
+ "val_mse": 0.04216707497835159,
+ "fit_time_sec": 2.4834530411753803,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.55,
+ "w_max": 0.55
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.55,
+ "w_max": 0.55,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_low_w_seed53_25937b680943"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_w_decay",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0393675565719604,
+ "train_acc": 0.6915000081062317,
+ "train_mse": 0.04423632100224495,
+ "val_loss": 1.025821566581726,
+ "val_acc": 0.6983333230018616,
+ "val_mse": 0.04372088611125946,
+ "fit_time_sec": 2.426888459129259,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_w_decay_seed51_cf3e7ce1c4f8"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_w_decay",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.1047112941741943,
+ "train_acc": 0.6600000262260437,
+ "train_mse": 0.04690749943256378,
+ "val_loss": 1.1661359071731567,
+ "val_acc": 0.6700000166893005,
+ "val_mse": 0.04753515496850014,
+ "fit_time_sec": 2.480164624983445,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_w_decay_seed52_d992bbf37f5a"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_w_decay",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9673198461532593,
+ "train_acc": 0.6909999847412109,
+ "train_mse": 0.04216654598712921,
+ "val_loss": 0.9870904684066772,
+ "val_acc": 0.6816666722297668,
+ "val_mse": 0.04321449622511864,
+ "fit_time_sec": 2.422041916055605,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_w_decay_seed53_9378397cdb0f"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_asymmetric",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0810083150863647,
+ "train_acc": 0.6775000095367432,
+ "train_mse": 0.04572315141558647,
+ "val_loss": 1.0954482555389404,
+ "val_acc": 0.6949999928474426,
+ "val_mse": 0.04539918154478073,
+ "fit_time_sec": 2.485565959010273,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_asymmetric_seed51_d79a7377935e"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_asymmetric",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9861184358596802,
+ "train_acc": 0.6909999847412109,
+ "train_mse": 0.04338207468390465,
+ "val_loss": 1.0121054649353027,
+ "val_acc": 0.6933333277702332,
+ "val_mse": 0.043754804879426956,
+ "fit_time_sec": 2.5209125420078635,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_asymmetric_seed52_e6cdbd66e151"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "inertia",
+ "candidate_label": "inertia_asymmetric",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9526417851448059,
+ "train_acc": 0.722000002861023,
+ "train_mse": 0.03998463600873947,
+ "val_loss": 0.9798429608345032,
+ "val_acc": 0.70333331823349,
+ "val_mse": 0.04217696189880371,
+ "fit_time_sec": 2.5959840829018503,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_inertia_asymmetric_seed53_32b967f0e0d1"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c201",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0345860719680786,
+ "train_acc": 0.6869999766349792,
+ "train_mse": 0.04355757310986519,
+ "val_loss": 0.9738073945045471,
+ "val_acc": 0.6916666626930237,
+ "val_mse": 0.042279358953237534,
+ "fit_time_sec": 2.698073250008747,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.01,
+ "c1": 2.01,
+ "chi": 0.8682255312124236
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.01,
+ "c1": 2.01,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c201_seed51_31fb46304ff6"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c201",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0233638286590576,
+ "train_acc": 0.6865000128746033,
+ "train_mse": 0.043414223939180374,
+ "val_loss": 1.0523117780685425,
+ "val_acc": 0.6883333325386047,
+ "val_mse": 0.043930795043706894,
+ "fit_time_sec": 3.4117308750282973,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.01,
+ "c1": 2.01,
+ "chi": 0.8682255312124236
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.01,
+ "c1": 2.01,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c201_seed52_a693e1c0a6f0"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c201",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0302053689956665,
+ "train_acc": 0.6880000233650208,
+ "train_mse": 0.043894827365875244,
+ "val_loss": 0.9275049567222595,
+ "val_acc": 0.7166666388511658,
+ "val_mse": 0.040264155715703964,
+ "fit_time_sec": 3.1805959579069167,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.01,
+ "c1": 2.01,
+ "chi": 0.8682255312124236
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.01,
+ "c1": 2.01,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c201_seed53_44697f297498"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c205_canonical",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0515944957733154,
+ "train_acc": 0.6759999990463257,
+ "train_mse": 0.04530733451247215,
+ "val_loss": 1.0619410276412964,
+ "val_acc": 0.6933333277702332,
+ "val_mse": 0.044216156005859375,
+ "fit_time_sec": 3.237764042103663,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.05,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c205_canonical_seed51_fc8c5b72834f"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c205_canonical",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.061699390411377,
+ "train_acc": 0.6744999885559082,
+ "train_mse": 0.04590365290641785,
+ "val_loss": 1.016150712966919,
+ "val_acc": 0.6866666674613953,
+ "val_mse": 0.0442710816860199,
+ "fit_time_sec": 2.7161605830769986,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.05,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c205_canonical_seed52_8c5872218781"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c205_canonical",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9327093362808228,
+ "train_acc": 0.7289999723434448,
+ "train_mse": 0.03894326463341713,
+ "val_loss": 0.8751127123832703,
+ "val_acc": 0.746666669845581,
+ "val_mse": 0.03667077049612999,
+ "fit_time_sec": 2.968678707955405,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.05,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c205_canonical_seed53_d2c08fcda660"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c205_tuned",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.053567886352539,
+ "train_acc": 0.6825000047683716,
+ "train_mse": 0.04465964064002037,
+ "val_loss": 0.991266667842865,
+ "val_acc": 0.699999988079071,
+ "val_mse": 0.04196731001138687,
+ "fit_time_sec": 3.042221749899909,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c205_tuned_seed51_643d9a60a8ab"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c205_tuned",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9388713836669922,
+ "train_acc": 0.7139999866485596,
+ "train_mse": 0.040887460112571716,
+ "val_loss": 0.9303705096244812,
+ "val_acc": 0.7116666436195374,
+ "val_mse": 0.0403158962726593,
+ "fit_time_sec": 2.8448961251415312,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c205_tuned_seed52_ee543423b362"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c205_tuned",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9965179562568665,
+ "train_acc": 0.6995000243186951,
+ "train_mse": 0.042770277708768845,
+ "val_loss": 0.9846652150154114,
+ "val_acc": 0.7133333086967468,
+ "val_mse": 0.04187808558344841,
+ "fit_time_sec": 3.1848887908272445,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c205_tuned_seed53_0af3451c66fa"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c250",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 2.2795634269714355,
+ "train_acc": 0.18150000274181366,
+ "train_mse": 0.08912184089422226,
+ "val_loss": 2.250452756881714,
+ "val_acc": 0.18666666746139526,
+ "val_mse": 0.08861013501882553,
+ "fit_time_sec": 2.9961123750545084,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.5,
+ "c1": 2.5,
+ "chi": 0.38196601125010515
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.5,
+ "c1": 2.5,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c250_seed51_d81da916363c"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c250",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 2.2547407150268555,
+ "train_acc": 0.20350000262260437,
+ "train_mse": 0.08870375156402588,
+ "val_loss": 2.2187206745147705,
+ "val_acc": 0.2150000035762787,
+ "val_mse": 0.08802558481693268,
+ "fit_time_sec": 3.024313250090927,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.5,
+ "c1": 2.5,
+ "chi": 0.38196601125010515
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.5,
+ "c1": 2.5,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c250_seed52_0db5c75ca7f9"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_c250",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 2.19023060798645,
+ "train_acc": 0.19300000369548798,
+ "train_mse": 0.08786869794130325,
+ "val_loss": 2.178219795227051,
+ "val_acc": 0.20499999821186066,
+ "val_mse": 0.08775272965431213,
+ "fit_time_sec": 2.961929291021079,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.5,
+ "c1": 2.5,
+ "chi": 0.38196601125010515
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.5,
+ "c1": 2.5,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_c250_seed53_32cd4a3047fd"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_asymmetric",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.2645200490951538,
+ "train_acc": 0.6150000095367432,
+ "train_mse": 0.053478311747312546,
+ "val_loss": 1.2170491218566895,
+ "val_acc": 0.6316666603088379,
+ "val_mse": 0.05265685170888901,
+ "fit_time_sec": 3.023697500117123,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.8,
+ "c1": 1.3,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.8,
+ "c1": 1.3,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_asymmetric_seed51_080d35af7a3a"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_asymmetric",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.2607256174087524,
+ "train_acc": 0.6014999747276306,
+ "train_mse": 0.05520418658852577,
+ "val_loss": 1.2684078216552734,
+ "val_acc": 0.5883333086967468,
+ "val_mse": 0.05453150346875191,
+ "fit_time_sec": 2.8057189998216927,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.8,
+ "c1": 1.3,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.8,
+ "c1": 1.3,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_asymmetric_seed52_c00ae44c3095"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "constriction",
+ "candidate_label": "constriction_asymmetric",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.2320771217346191,
+ "train_acc": 0.6140000224113464,
+ "train_mse": 0.05192725360393524,
+ "val_loss": 1.2376829385757446,
+ "val_acc": 0.6200000047683716,
+ "val_mse": 0.05186690762639046,
+ "fit_time_sec": 2.709051915910095,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.8,
+ "c1": 1.3,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.8,
+ "c1": 1.3,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_constriction_asymmetric_seed53_25127f313178"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r1_constant",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4435429573059082,
+ "train_acc": 0.5354999899864197,
+ "train_mse": 0.06257098913192749,
+ "val_loss": 1.4319947957992554,
+ "val_acc": 0.528333306312561,
+ "val_mse": 0.062414027750492096,
+ "fit_time_sec": 2.6544057081919163,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 1
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 1,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r1_constant_seed51_eb0ed6970d2c"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r1_constant",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4914970397949219,
+ "train_acc": 0.527999997138977,
+ "train_mse": 0.06460313498973846,
+ "val_loss": 1.4473850727081299,
+ "val_acc": 0.5333333611488342,
+ "val_mse": 0.06336859613656998,
+ "fit_time_sec": 2.7407990000210702,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 1
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 1,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r1_constant_seed52_61433fa64071"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r1_constant",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4734760522842407,
+ "train_acc": 0.5680000185966492,
+ "train_mse": 0.06238424777984619,
+ "val_loss": 1.5045198202133179,
+ "val_acc": 0.5366666913032532,
+ "val_mse": 0.06426934152841568,
+ "fit_time_sec": 2.693694499786943,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 1
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 1,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r1_constant_seed53_445930c79d85"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r2_constant",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.2284750938415527,
+ "train_acc": 0.6345000267028809,
+ "train_mse": 0.0517057403922081,
+ "val_loss": 1.191932201385498,
+ "val_acc": 0.628333330154419,
+ "val_mse": 0.0514327734708786,
+ "fit_time_sec": 2.4563205409795046,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 2
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 2,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r2_constant_seed51_279d68306b43"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r2_constant",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.1704559326171875,
+ "train_acc": 0.6504999995231628,
+ "train_mse": 0.050959013402462006,
+ "val_loss": 1.1325551271438599,
+ "val_acc": 0.6700000166893005,
+ "val_mse": 0.049076274037361145,
+ "fit_time_sec": 2.5833707919809967,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 2
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 2,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r2_constant_seed52_23bc1e4c9bb8"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r2_constant",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.243313193321228,
+ "train_acc": 0.6320000290870667,
+ "train_mse": 0.05307132005691528,
+ "val_loss": 1.2125868797302246,
+ "val_acc": 0.6516666412353516,
+ "val_mse": 0.05214923247694969,
+ "fit_time_sec": 2.475700625218451,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 2
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 2,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r2_constant_seed53_b6a734a7a024"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r4_constant",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0172255039215088,
+ "train_acc": 0.6884999871253967,
+ "train_mse": 0.04337601363658905,
+ "val_loss": 1.0000126361846924,
+ "val_acc": 0.699999988079071,
+ "val_mse": 0.0425647497177124,
+ "fit_time_sec": 2.4682277080137283,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 4
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 4,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r4_constant_seed51_eb2af7d5806d"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r4_constant",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9992414712905884,
+ "train_acc": 0.7089999914169312,
+ "train_mse": 0.04267498105764389,
+ "val_loss": 0.9295963644981384,
+ "val_acc": 0.7283333539962769,
+ "val_mse": 0.04094172641634941,
+ "fit_time_sec": 2.4259307920001447,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 4
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 4,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r4_constant_seed52_ef54890d1679"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r4_constant",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9578440189361572,
+ "train_acc": 0.7139999866485596,
+ "train_mse": 0.041153207421302795,
+ "val_loss": 0.9051287770271301,
+ "val_acc": 0.7450000047683716,
+ "val_mse": 0.03751235082745552,
+ "fit_time_sec": 2.4171505419071764,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 4
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 4,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r4_constant_seed53_05bb06b328f5"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r1_decay",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4906078577041626,
+ "train_acc": 0.5640000104904175,
+ "train_mse": 0.06397789716720581,
+ "val_loss": 1.4867504835128784,
+ "val_acc": 0.5400000214576721,
+ "val_mse": 0.06405453383922577,
+ "fit_time_sec": 2.455931582953781,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "neighborhood_radius": 1
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "method_options": {
+ "neighborhood_radius": 1,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r1_decay_seed51_a34b661481e6"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r1_decay",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4803287982940674,
+ "train_acc": 0.5559999942779541,
+ "train_mse": 0.06340162456035614,
+ "val_loss": 1.4699759483337402,
+ "val_acc": 0.5733333230018616,
+ "val_mse": 0.0630197748541832,
+ "fit_time_sec": 2.5800107079558074,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "neighborhood_radius": 1
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "method_options": {
+ "neighborhood_radius": 1,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r1_decay_seed52_a67065fa6297"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "local_best",
+ "candidate_label": "local_best_r1_decay",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4953768253326416,
+ "train_acc": 0.5370000004768372,
+ "train_mse": 0.06418897211551666,
+ "val_loss": 1.4344968795776367,
+ "val_acc": 0.5416666865348816,
+ "val_mse": 0.06267009675502777,
+ "fit_time_sec": 2.5192452499177307,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "neighborhood_radius": 1
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "method_options": {
+ "neighborhood_radius": 1,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.4,
+ "w_max": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_local_best_r1_decay_seed53_5d33e9a3b14d"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.5_1.0",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4666624069213867,
+ "train_acc": 0.5055000185966492,
+ "train_mse": 0.06231168285012245,
+ "val_loss": 1.4257338047027588,
+ "val_acc": 0.5183333158493042,
+ "val_mse": 0.06076965853571892,
+ "fit_time_sec": 2.411743083037436,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.5,
+ "beta_max": 1.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.5,
+ "beta_max": 1.0
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.5_1.0_seed51_bb65dcd4293e"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.5_1.0",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4086458683013916,
+ "train_acc": 0.5370000004768372,
+ "train_mse": 0.06125783920288086,
+ "val_loss": 1.3660792112350464,
+ "val_acc": 0.5383333563804626,
+ "val_mse": 0.05962810665369034,
+ "fit_time_sec": 2.398069208022207,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.5,
+ "beta_max": 1.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.5,
+ "beta_max": 1.0
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.5_1.0_seed52_4ee0030598ae"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.5_1.0",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.3147938251495361,
+ "train_acc": 0.5580000281333923,
+ "train_mse": 0.05813988670706749,
+ "val_loss": 1.295978307723999,
+ "val_acc": 0.574999988079071,
+ "val_mse": 0.05797567218542099,
+ "fit_time_sec": 2.4090406668838114,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.5,
+ "beta_max": 1.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.5,
+ "beta_max": 1.0
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.5_1.0_seed53_5698f8ef063c"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.6_1.0",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.7944316864013672,
+ "train_acc": 0.3955000042915344,
+ "train_mse": 0.07452504336833954,
+ "val_loss": 1.7316218614578247,
+ "val_acc": 0.4050000011920929,
+ "val_mse": 0.07277336716651917,
+ "fit_time_sec": 2.4751413341145962,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.6,
+ "beta_max": 1.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.6,
+ "beta_max": 1.0
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.6_1.0_seed51_4cf40096997e"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.6_1.0",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.770385980606079,
+ "train_acc": 0.3785000145435333,
+ "train_mse": 0.07627403736114502,
+ "val_loss": 1.7482523918151855,
+ "val_acc": 0.3866666555404663,
+ "val_mse": 0.07508829981088638,
+ "fit_time_sec": 2.41624170797877,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.6,
+ "beta_max": 1.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.6,
+ "beta_max": 1.0
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.6_1.0_seed52_b8cf5face5ea"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.6_1.0",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.711459994316101,
+ "train_acc": 0.4320000112056732,
+ "train_mse": 0.07082363963127136,
+ "val_loss": 1.684290885925293,
+ "val_acc": 0.4399999976158142,
+ "val_mse": 0.07037489116191864,
+ "fit_time_sec": 2.4244089999701828,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.6,
+ "beta_max": 1.0
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.6,
+ "beta_max": 1.0
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.6_1.0_seed53_0dc659272cc4"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.5_1.2",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.6640392541885376,
+ "train_acc": 0.4580000042915344,
+ "train_mse": 0.06881032139062881,
+ "val_loss": 1.6313401460647583,
+ "val_acc": 0.43833333253860474,
+ "val_mse": 0.0688972994685173,
+ "fit_time_sec": 2.379183917073533,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.5,
+ "beta_max": 1.2
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.5,
+ "beta_max": 1.2
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.5_1.2_seed51_c4a274ec6a1f"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.5_1.2",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.5431870222091675,
+ "train_acc": 0.49149999022483826,
+ "train_mse": 0.06610891968011856,
+ "val_loss": 1.515285849571228,
+ "val_acc": 0.5133333206176758,
+ "val_mse": 0.06496633589267731,
+ "fit_time_sec": 2.3730562501586974,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.5,
+ "beta_max": 1.2
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.5,
+ "beta_max": 1.2
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.5_1.2_seed52_876d9cd41977"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.5_1.2",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.7410157918930054,
+ "train_acc": 0.4059999883174896,
+ "train_mse": 0.07398762553930283,
+ "val_loss": 1.7098183631896973,
+ "val_acc": 0.3916666805744171,
+ "val_mse": 0.07386184483766556,
+ "fit_time_sec": 2.438973000040278,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.5,
+ "beta_max": 1.2
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.5,
+ "beta_max": 1.2
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.5_1.2_seed53_11db1f78c192"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.4_0.9",
+ "seed": 51,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4330989122390747,
+ "train_acc": 0.512499988079071,
+ "train_mse": 0.06236521154642105,
+ "val_loss": 1.369968295097351,
+ "val_acc": 0.5433333516120911,
+ "val_mse": 0.06111948564648628,
+ "fit_time_sec": 2.5881015001796186,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "82b3214d02e2e634",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.4_0.9_seed51_972bc34a235d"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.4_0.9",
+ "seed": 52,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4685417413711548,
+ "train_acc": 0.5249999761581421,
+ "train_mse": 0.06346181780099869,
+ "val_loss": 1.3982360363006592,
+ "val_acc": 0.5716666579246521,
+ "val_mse": 0.06072157621383667,
+ "fit_time_sec": 2.5672016669996083,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "ddffbe335bef15ad",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.4_0.9_seed52_ae077aec756e"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "search",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.4_0.9",
+ "seed": 53,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.3139362335205078,
+ "train_acc": 0.5789999961853027,
+ "train_mse": 0.05647370219230652,
+ "val_loss": 1.244922161102295,
+ "val_acc": 0.5799999833106995,
+ "val_mse": 0.056043192744255066,
+ "fit_time_sec": 2.4583064999897033,
+ "data_fingerprint": "bfc8de485755d7f3",
+ "model_fingerprint": "00868f788440b8a0",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "search_quantum_beta_0.4_0.9_seed53_63645cd92e47"
+ }
+ ],
+ "confirmation_runs": [
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 61,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0297304391860962,
+ "train_acc": 0.6644999980926514,
+ "train_mse": 0.046309761703014374,
+ "test_loss": 1.2476433515548706,
+ "test_acc": 0.5960000157356262,
+ "test_mse": 0.054337989538908005,
+ "fit_time_sec": 3.3018275420181453,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2a1760dc9ec95c0a",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_adaptive_moment_am_b0.06_s0.5_seed61_e0e742f6fe58"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 62,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0248669385910034,
+ "train_acc": 0.6800000071525574,
+ "train_mse": 0.044338468462228775,
+ "test_loss": 1.2172735929489136,
+ "test_acc": 0.6150000095367432,
+ "test_mse": 0.05301284044981003,
+ "fit_time_sec": 3.082969541894272,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "8722b0d78b78d382",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_adaptive_moment_am_b0.06_s0.5_seed62_74fb2b89b470"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 63,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0421160459518433,
+ "train_acc": 0.6690000295639038,
+ "train_mse": 0.04584677889943123,
+ "test_loss": 1.2344101667404175,
+ "test_acc": 0.6190000176429749,
+ "test_mse": 0.052518151700496674,
+ "fit_time_sec": 2.7472599998582155,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "f9f62f1942f9151e",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_adaptive_moment_am_b0.06_s0.5_seed63_02e481a3f363"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 64,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9773346185684204,
+ "train_acc": 0.7059999704360962,
+ "train_mse": 0.041074566543102264,
+ "test_loss": 1.1978241205215454,
+ "test_acc": 0.6150000095367432,
+ "test_mse": 0.052042748779058456,
+ "fit_time_sec": 2.670909541891888,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4cd40d38555ee5ce",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_adaptive_moment_am_b0.06_s0.5_seed64_19687a187644"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 65,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0047204494476318,
+ "train_acc": 0.6959999799728394,
+ "train_mse": 0.04294333606958389,
+ "test_loss": 1.2509828805923462,
+ "test_acc": 0.6079999804496765,
+ "test_mse": 0.05341806635260582,
+ "fit_time_sec": 2.9130489169619977,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "70f99d26e1303b76",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_adaptive_moment_am_b0.06_s0.5_seed65_45bea64c4340"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "inertia",
+ "candidate_label": "inertia_asymmetric",
+ "seed": 61,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0274338722229004,
+ "train_acc": 0.6735000014305115,
+ "train_mse": 0.04481710121035576,
+ "test_loss": 1.2075469493865967,
+ "test_acc": 0.6320000290870667,
+ "test_mse": 0.051997773349285126,
+ "fit_time_sec": 2.564156916923821,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2a1760dc9ec95c0a",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_inertia_inertia_asymmetric_seed61_4724cbb71341"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "inertia",
+ "candidate_label": "inertia_asymmetric",
+ "seed": 62,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9986715912818909,
+ "train_acc": 0.6855000257492065,
+ "train_mse": 0.043963707983493805,
+ "test_loss": 1.2740414142608643,
+ "test_acc": 0.578000009059906,
+ "test_mse": 0.056466199457645416,
+ "fit_time_sec": 2.5913295838981867,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "8722b0d78b78d382",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_inertia_inertia_asymmetric_seed62_2566bc98b863"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "inertia",
+ "candidate_label": "inertia_asymmetric",
+ "seed": 63,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.8828525543212891,
+ "train_acc": 0.7315000295639038,
+ "train_mse": 0.03869428485631943,
+ "test_loss": 1.0797629356384277,
+ "test_acc": 0.6620000004768372,
+ "test_mse": 0.04682194069027901,
+ "fit_time_sec": 2.6188287080731243,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "f9f62f1942f9151e",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_inertia_inertia_asymmetric_seed63_5ef6897f43ab"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "inertia",
+ "candidate_label": "inertia_asymmetric",
+ "seed": 64,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9942940473556519,
+ "train_acc": 0.6865000128746033,
+ "train_mse": 0.043017033487558365,
+ "test_loss": 1.2426005601882935,
+ "test_acc": 0.621999979019165,
+ "test_mse": 0.05173056200146675,
+ "fit_time_sec": 2.534188667079434,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4cd40d38555ee5ce",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_inertia_inertia_asymmetric_seed64_0ef61137ad79"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "inertia",
+ "candidate_label": "inertia_asymmetric",
+ "seed": 65,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0921698808670044,
+ "train_acc": 0.6729999780654907,
+ "train_mse": 0.04589727148413658,
+ "test_loss": 1.2609055042266846,
+ "test_acc": 0.6209999918937683,
+ "test_mse": 0.052379049360752106,
+ "fit_time_sec": 2.542070833966136,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "70f99d26e1303b76",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Inertia Weight PSO",
+ "source": "10.1109/ICEC.1998.699146",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "inertia",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.8,
+ "c1": 1.2,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_inertia_inertia_asymmetric_seed65_46915e745846"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "constriction",
+ "candidate_label": "constriction_c205_canonical",
+ "seed": 61,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0248574018478394,
+ "train_acc": 0.6919999718666077,
+ "train_mse": 0.04333744943141937,
+ "test_loss": 1.2035431861877441,
+ "test_acc": 0.6299999952316284,
+ "test_mse": 0.05152203515172005,
+ "fit_time_sec": 2.5165979999583215,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2a1760dc9ec95c0a",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.05,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_constriction_constriction_c205_canonical_seed61_9019cd9ce38f"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "constriction",
+ "candidate_label": "constriction_c205_canonical",
+ "seed": 62,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.1310851573944092,
+ "train_acc": 0.6700000166893005,
+ "train_mse": 0.046749312430620193,
+ "test_loss": 1.3196481466293335,
+ "test_acc": 0.5849999785423279,
+ "test_mse": 0.055950723588466644,
+ "fit_time_sec": 2.481917541939765,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "8722b0d78b78d382",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.05,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_constriction_constriction_c205_canonical_seed62_46d2fef1bc63"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "constriction",
+ "candidate_label": "constriction_c205_canonical",
+ "seed": 63,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0529502630233765,
+ "train_acc": 0.6644999980926514,
+ "train_mse": 0.04611203819513321,
+ "test_loss": 1.2498247623443604,
+ "test_acc": 0.5789999961853027,
+ "test_mse": 0.05548400804400444,
+ "fit_time_sec": 2.593008500058204,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "f9f62f1942f9151e",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.05,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_constriction_constriction_c205_canonical_seed63_d7c98a90a890"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "constriction",
+ "candidate_label": "constriction_c205_canonical",
+ "seed": 64,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9444444179534912,
+ "train_acc": 0.7145000100135803,
+ "train_mse": 0.04049043729901314,
+ "test_loss": 1.2384077310562134,
+ "test_acc": 0.6179999709129333,
+ "test_mse": 0.0526747927069664,
+ "fit_time_sec": 2.4862103750929236,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4cd40d38555ee5ce",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.05,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_constriction_constriction_c205_canonical_seed64_9178a53fa605"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "constriction",
+ "candidate_label": "constriction_c205_canonical",
+ "seed": 65,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9420643448829651,
+ "train_acc": 0.7105000019073486,
+ "train_mse": 0.041058044880628586,
+ "test_loss": 1.219950795173645,
+ "test_acc": 0.6209999918937683,
+ "test_mse": 0.051569391041994095,
+ "fit_time_sec": 2.5256920421961695,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "70f99d26e1303b76",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Constriction Coefficient PSO",
+ "source": "10.1109/4235.985692",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 2.05,
+ "c1": 2.05,
+ "chi": 0.7298437881283576
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "constriction",
+ "velocity_limit_ratio": 0.05,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 2.05,
+ "c1": 2.05,
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_constriction_constriction_c205_canonical_seed65_35f49c87ae7e"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "local_best",
+ "candidate_label": "local_best_r4_constant",
+ "seed": 61,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0233083963394165,
+ "train_acc": 0.703499972820282,
+ "train_mse": 0.04417002946138382,
+ "test_loss": 1.1751943826675415,
+ "test_acc": 0.6549999713897705,
+ "test_mse": 0.050412945449352264,
+ "fit_time_sec": 2.535716458922252,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2a1760dc9ec95c0a",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 4
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 4,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_local_best_local_best_r4_constant_seed61_73f3ed288805"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "local_best",
+ "candidate_label": "local_best_r4_constant",
+ "seed": 62,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0379226207733154,
+ "train_acc": 0.6970000267028809,
+ "train_mse": 0.04612046852707863,
+ "test_loss": 1.2656233310699463,
+ "test_acc": 0.593999981880188,
+ "test_mse": 0.056342579424381256,
+ "fit_time_sec": 2.5843862500041723,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "8722b0d78b78d382",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 4
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 4,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_local_best_local_best_r4_constant_seed62_eebfde8d3783"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "local_best",
+ "candidate_label": "local_best_r4_constant",
+ "seed": 63,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9664440751075745,
+ "train_acc": 0.7275000214576721,
+ "train_mse": 0.04065090790390968,
+ "test_loss": 1.167758584022522,
+ "test_acc": 0.6570000052452087,
+ "test_mse": 0.049540925770998,
+ "fit_time_sec": 2.485073500080034,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "f9f62f1942f9151e",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 4
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 4,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_local_best_local_best_r4_constant_seed63_6fe7e88eef36"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "local_best",
+ "candidate_label": "local_best_r4_constant",
+ "seed": 64,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0115971565246582,
+ "train_acc": 0.703000009059906,
+ "train_mse": 0.044141702353954315,
+ "test_loss": 1.1620168685913086,
+ "test_acc": 0.625,
+ "test_mse": 0.052118122577667236,
+ "fit_time_sec": 2.467889874940738,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4cd40d38555ee5ce",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 4
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 4,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_local_best_local_best_r4_constant_seed64_1a97e042ff3e"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "local_best",
+ "candidate_label": "local_best_r4_constant",
+ "seed": 65,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0574767589569092,
+ "train_acc": 0.6959999799728394,
+ "train_mse": 0.045724473893642426,
+ "test_loss": 1.286249041557312,
+ "test_acc": 0.6010000109672546,
+ "test_mse": 0.05573433265089989,
+ "fit_time_sec": 2.488020292017609,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "70f99d26e1303b76",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Ring Local Best PSO",
+ "source": "10.1109/CEC.2002.1004493",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "neighborhood_radius": 4
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "local_best",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "neighborhood_radius": 4,
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_local_best_local_best_r4_constant_seed65_0c8c6ac7d8a4"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.4_0.9",
+ "seed": 61,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4583405256271362,
+ "train_acc": 0.5460000038146973,
+ "train_mse": 0.06230271980166435,
+ "test_loss": 1.464557409286499,
+ "test_acc": 0.5320000052452087,
+ "test_mse": 0.06282258033752441,
+ "fit_time_sec": 2.3820620418991894,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2a1760dc9ec95c0a",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_quantum_quantum_beta_0.4_0.9_seed61_a2e8b7676470"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.4_0.9",
+ "seed": 62,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.5153175592422485,
+ "train_acc": 0.5084999799728394,
+ "train_mse": 0.06375879794359207,
+ "test_loss": 1.5834708213806152,
+ "test_acc": 0.4650000035762787,
+ "test_mse": 0.0668596550822258,
+ "fit_time_sec": 2.4394417498260736,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "8722b0d78b78d382",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_quantum_quantum_beta_0.4_0.9_seed62_762584f88912"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.4_0.9",
+ "seed": 63,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.4202407598495483,
+ "train_acc": 0.5490000247955322,
+ "train_mse": 0.059825461357831955,
+ "test_loss": 1.5065674781799316,
+ "test_acc": 0.4860000014305115,
+ "test_mse": 0.06405868381261826,
+ "fit_time_sec": 2.3948492500931025,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "f9f62f1942f9151e",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_quantum_quantum_beta_0.4_0.9_seed63_268565cdbc8f"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.4_0.9",
+ "seed": 64,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.3938108682632446,
+ "train_acc": 0.5199999809265137,
+ "train_mse": 0.06204824894666672,
+ "test_loss": 1.4775264263153076,
+ "test_acc": 0.46799999475479126,
+ "test_mse": 0.06637361645698547,
+ "fit_time_sec": 2.3948124169837683,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4cd40d38555ee5ce",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_quantum_quantum_beta_0.4_0.9_seed64_968dd6fa0571"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "confirmation",
+ "method": "quantum",
+ "candidate_label": "quantum_beta_0.4_0.9",
+ "seed": 65,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.3520328998565674,
+ "train_acc": 0.5724999904632568,
+ "train_mse": 0.05604845657944679,
+ "test_loss": 1.5641074180603027,
+ "test_acc": 0.4779999852180481,
+ "test_mse": 0.06454122811555862,
+ "fit_time_sec": 2.402772541856393,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "70f99d26e1303b76",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Quantum PSO",
+ "source": "10.1109/CEC.2004.1330875",
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "quantum",
+ "velocity_limit_ratio": null,
+ "mutation_swarm": 0.0,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "method_options": {
+ "beta_min": 0.4,
+ "beta_max": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "confirm_quantum_quantum_beta_0.4_0.9_seed65_55d400304d8b"
+ }
+ ],
+ "scaling_runs": [
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 71,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0238605737686157,
+ "train_acc": 0.6834999918937683,
+ "train_mse": 0.044781655073165894,
+ "test_loss": 1.2778329849243164,
+ "test_acc": 0.5789999961853027,
+ "test_mse": 0.05719960853457451,
+ "fit_time_sec": 2.591740084113553,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0777bd52fd76272d",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_30p_80e_fixed_epoch_seed71_9275568c45fc",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 72,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0670214891433716,
+ "train_acc": 0.6604999899864197,
+ "train_mse": 0.04655227065086365,
+ "test_loss": 1.199388861656189,
+ "test_acc": 0.6060000061988831,
+ "test_mse": 0.052410222589969635,
+ "fit_time_sec": 2.7087553329765797,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_30p_80e_fixed_epoch_seed72_664dc1187b00",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 73,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9569582939147949,
+ "train_acc": 0.7014999985694885,
+ "train_mse": 0.0413692481815815,
+ "test_loss": 1.1562552452087402,
+ "test_acc": 0.6389999985694885,
+ "test_mse": 0.051246583461761475,
+ "fit_time_sec": 2.6669440830592066,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2e6c351372592f10",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_30p_80e_fixed_epoch_seed73_f73fe00c1aab",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 74,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.8988860845565796,
+ "train_acc": 0.718999981880188,
+ "train_mse": 0.03921135887503624,
+ "test_loss": 1.0667707920074463,
+ "test_acc": 0.6589999794960022,
+ "test_mse": 0.047151338309049606,
+ "fit_time_sec": 2.6316912909969687,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4000fe3fb26ef207",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_30p_80e_fixed_epoch_seed74_f703eea6cd6a",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 75,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9674410820007324,
+ "train_acc": 0.7139999866485596,
+ "train_mse": 0.04114193841814995,
+ "test_loss": 1.2670954465866089,
+ "test_acc": 0.6230000257492065,
+ "test_mse": 0.052300941199064255,
+ "fit_time_sec": 2.8266918330918998,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0966039f5ef7af88",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_30p_80e_fixed_epoch_seed75_5dd29e885bd8",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 71,
+ "n_particles": 60,
+ "epochs": 80,
+ "particle_epochs": 4800,
+ "train_loss": 0.8341852426528931,
+ "train_acc": 0.7419999837875366,
+ "train_mse": 0.036770910024642944,
+ "test_loss": 1.021918535232544,
+ "test_acc": 0.6729999780654907,
+ "test_mse": 0.0449918694794178,
+ "fit_time_sec": 6.297774499980733,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0777bd52fd76272d",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 60,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_60p_80e_fixed_epoch_seed71_d6f7409ead05",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 72,
+ "n_particles": 60,
+ "epochs": 80,
+ "particle_epochs": 4800,
+ "train_loss": 0.8334679007530212,
+ "train_acc": 0.7580000162124634,
+ "train_mse": 0.0346507728099823,
+ "test_loss": 1.1486669778823853,
+ "test_acc": 0.6499999761581421,
+ "test_mse": 0.048473432660102844,
+ "fit_time_sec": 5.944013542030007,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 60,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_60p_80e_fixed_epoch_seed72_f6cc409842c9",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 73,
+ "n_particles": 60,
+ "epochs": 80,
+ "particle_epochs": 4800,
+ "train_loss": 0.7845665216445923,
+ "train_acc": 0.7599999904632568,
+ "train_mse": 0.03348695859313011,
+ "test_loss": 1.059795618057251,
+ "test_acc": 0.6589999794960022,
+ "test_mse": 0.04623967781662941,
+ "fit_time_sec": 5.409191000042483,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2e6c351372592f10",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 60,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_60p_80e_fixed_epoch_seed73_e225cf4bcba5",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 74,
+ "n_particles": 60,
+ "epochs": 80,
+ "particle_epochs": 4800,
+ "train_loss": 0.8425021767616272,
+ "train_acc": 0.7400000095367432,
+ "train_mse": 0.036814577877521515,
+ "test_loss": 1.0703872442245483,
+ "test_acc": 0.6610000133514404,
+ "test_mse": 0.046978432685136795,
+ "fit_time_sec": 5.092122667003423,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4000fe3fb26ef207",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 60,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_60p_80e_fixed_epoch_seed74_5f61422d77d1",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 75,
+ "n_particles": 60,
+ "epochs": 80,
+ "particle_epochs": 4800,
+ "train_loss": 0.7727756500244141,
+ "train_acc": 0.753000020980835,
+ "train_mse": 0.03384615480899811,
+ "test_loss": 1.0723776817321777,
+ "test_acc": 0.6539999842643738,
+ "test_mse": 0.04744390770792961,
+ "fit_time_sec": 5.18646250013262,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0966039f5ef7af88",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 60,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_60p_80e_fixed_epoch_seed75_dd5a845500dc",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 71,
+ "n_particles": 90,
+ "epochs": 80,
+ "particle_epochs": 7200,
+ "train_loss": 0.6898615956306458,
+ "train_acc": 0.7910000085830688,
+ "train_mse": 0.029968174174427986,
+ "test_loss": 0.8688502311706543,
+ "test_acc": 0.7310000061988831,
+ "test_mse": 0.03894031420350075,
+ "fit_time_sec": 8.216789624886587,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0777bd52fd76272d",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 90,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_90p_80e_fixed_epoch_seed71_bbe723279f9d",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 72,
+ "n_particles": 90,
+ "epochs": 80,
+ "particle_epochs": 7200,
+ "train_loss": 0.7159585952758789,
+ "train_acc": 0.781499981880188,
+ "train_mse": 0.030635599046945572,
+ "test_loss": 0.9239839911460876,
+ "test_acc": 0.718999981880188,
+ "test_mse": 0.040356870740652084,
+ "fit_time_sec": 8.96910895803012,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 90,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_90p_80e_fixed_epoch_seed72_e898b08da07a",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 73,
+ "n_particles": 90,
+ "epochs": 80,
+ "particle_epochs": 7200,
+ "train_loss": 0.738656759262085,
+ "train_acc": 0.7760000228881836,
+ "train_mse": 0.032128240913152695,
+ "test_loss": 0.9498289227485657,
+ "test_acc": 0.6959999799728394,
+ "test_mse": 0.04225980117917061,
+ "fit_time_sec": 9.117825584020466,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2e6c351372592f10",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 90,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_90p_80e_fixed_epoch_seed73_bf63bb695b9b",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 74,
+ "n_particles": 90,
+ "epochs": 80,
+ "particle_epochs": 7200,
+ "train_loss": 0.7267816066741943,
+ "train_acc": 0.7770000100135803,
+ "train_mse": 0.031841080635786057,
+ "test_loss": 0.954045295715332,
+ "test_acc": 0.6769999861717224,
+ "test_mse": 0.04218713194131851,
+ "fit_time_sec": 8.722332582809031,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4000fe3fb26ef207",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 90,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_90p_80e_fixed_epoch_seed74_06d4bc72a2ed",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 75,
+ "n_particles": 90,
+ "epochs": 80,
+ "particle_epochs": 7200,
+ "train_loss": 0.7104133367538452,
+ "train_acc": 0.7889999747276306,
+ "train_mse": 0.030791515484452248,
+ "test_loss": 0.962693989276886,
+ "test_acc": 0.6930000185966492,
+ "test_mse": 0.04196783900260925,
+ "fit_time_sec": 8.110321166925132,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0966039f5ef7af88",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 90,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_90p_80e_fixed_epoch_seed75_3cdacc3f38c0",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 71,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6516683101654053,
+ "train_acc": 0.7950000166893005,
+ "train_mse": 0.028850017115473747,
+ "test_loss": 0.8584634065628052,
+ "test_acc": 0.7360000014305115,
+ "test_mse": 0.037673790007829666,
+ "fit_time_sec": 11.962705624988303,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0777bd52fd76272d",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_80e_fixed_epoch_seed71_e66d603db8f5",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 72,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6982801556587219,
+ "train_acc": 0.7914999723434448,
+ "train_mse": 0.030153820291161537,
+ "test_loss": 0.9025362133979797,
+ "test_acc": 0.7239999771118164,
+ "test_mse": 0.038956169039011,
+ "fit_time_sec": 11.906837583053857,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_80e_fixed_epoch_seed72_47cdadf9a983",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 73,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.7527623772621155,
+ "train_acc": 0.7749999761581421,
+ "train_mse": 0.032556530088186264,
+ "test_loss": 1.001193642616272,
+ "test_acc": 0.6919999718666077,
+ "test_mse": 0.04309915751218796,
+ "fit_time_sec": 10.664651792030782,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2e6c351372592f10",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_80e_fixed_epoch_seed73_78208b86e119",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 74,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6858600974082947,
+ "train_acc": 0.784500002861023,
+ "train_mse": 0.030640259385108948,
+ "test_loss": 0.8601324558258057,
+ "test_acc": 0.7350000143051147,
+ "test_mse": 0.03845023736357689,
+ "fit_time_sec": 10.921957665821537,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4000fe3fb26ef207",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_80e_fixed_epoch_seed74_e44bd395ec76",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 75,
+ "n_particles": 120,
+ "epochs": 80,
+ "particle_epochs": 9600,
+ "train_loss": 0.6326538324356079,
+ "train_acc": 0.8125,
+ "train_mse": 0.02839995175600052,
+ "test_loss": 0.889915406703949,
+ "test_acc": 0.7300000190734863,
+ "test_mse": 0.03931796923279762,
+ "fit_time_sec": 10.411899874918163,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0966039f5ef7af88",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_80e_fixed_epoch_seed75_17aefd097619",
+ "regimen": "fixed_epoch"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 71,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0238605737686157,
+ "train_acc": 0.6834999918937683,
+ "train_mse": 0.044781655073165894,
+ "test_loss": 1.2778329849243164,
+ "test_acc": 0.5789999961853027,
+ "test_mse": 0.05719960853457451,
+ "fit_time_sec": 2.591740084113553,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0777bd52fd76272d",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_30p_80e_fixed_budget_seed71_ad4f5f56fc08",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 72,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 1.0670214891433716,
+ "train_acc": 0.6604999899864197,
+ "train_mse": 0.04655227065086365,
+ "test_loss": 1.199388861656189,
+ "test_acc": 0.6060000061988831,
+ "test_mse": 0.052410222589969635,
+ "fit_time_sec": 2.7087553329765797,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_30p_80e_fixed_budget_seed72_c91605717855",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 73,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9569582939147949,
+ "train_acc": 0.7014999985694885,
+ "train_mse": 0.0413692481815815,
+ "test_loss": 1.1562552452087402,
+ "test_acc": 0.6389999985694885,
+ "test_mse": 0.051246583461761475,
+ "fit_time_sec": 2.6669440830592066,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2e6c351372592f10",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_30p_80e_fixed_budget_seed73_93b5bd82f1d3",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 74,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.8988860845565796,
+ "train_acc": 0.718999981880188,
+ "train_mse": 0.03921135887503624,
+ "test_loss": 1.0667707920074463,
+ "test_acc": 0.6589999794960022,
+ "test_mse": 0.047151338309049606,
+ "fit_time_sec": 2.6316912909969687,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4000fe3fb26ef207",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_30p_80e_fixed_budget_seed74_a4e354610e4d",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 75,
+ "n_particles": 30,
+ "epochs": 80,
+ "particle_epochs": 2400,
+ "train_loss": 0.9674410820007324,
+ "train_acc": 0.7139999866485596,
+ "train_mse": 0.04114193841814995,
+ "test_loss": 1.2670954465866089,
+ "test_acc": 0.6230000257492065,
+ "test_mse": 0.052300941199064255,
+ "fit_time_sec": 2.8266918330918998,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0966039f5ef7af88",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 30,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_30p_80e_fixed_budget_seed75_d1681e6e7ae0",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 71,
+ "n_particles": 60,
+ "epochs": 40,
+ "particle_epochs": 2400,
+ "train_loss": 1.3702143430709839,
+ "train_acc": 0.5690000057220459,
+ "train_mse": 0.0591430589556694,
+ "test_loss": 1.5396113395690918,
+ "test_acc": 0.49000000953674316,
+ "test_mse": 0.06583584100008011,
+ "fit_time_sec": 2.6427467500325292,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0777bd52fd76272d",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 60,
+ "epochs": 40,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_60p_40e_fixed_budget_seed71_6fae35a67da9",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 72,
+ "n_particles": 60,
+ "epochs": 40,
+ "particle_epochs": 2400,
+ "train_loss": 1.3834563493728638,
+ "train_acc": 0.5490000247955322,
+ "train_mse": 0.05912359058856964,
+ "test_loss": 1.564630150794983,
+ "test_acc": 0.5270000100135803,
+ "test_mse": 0.06432151794433594,
+ "fit_time_sec": 2.897082625189796,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 60,
+ "epochs": 40,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_60p_40e_fixed_budget_seed72_6fa47e021e5b",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 73,
+ "n_particles": 60,
+ "epochs": 40,
+ "particle_epochs": 2400,
+ "train_loss": 1.239696979522705,
+ "train_acc": 0.6129999756813049,
+ "train_mse": 0.0534692220389843,
+ "test_loss": 1.4340611696243286,
+ "test_acc": 0.5109999775886536,
+ "test_mse": 0.06299576163291931,
+ "fit_time_sec": 2.8362932079471648,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2e6c351372592f10",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 60,
+ "epochs": 40,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_60p_40e_fixed_budget_seed73_e4ccdee8c275",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 74,
+ "n_particles": 60,
+ "epochs": 40,
+ "particle_epochs": 2400,
+ "train_loss": 1.3051151037216187,
+ "train_acc": 0.593500018119812,
+ "train_mse": 0.05637447535991669,
+ "test_loss": 1.4914799928665161,
+ "test_acc": 0.5370000004768372,
+ "test_mse": 0.06303515285253525,
+ "fit_time_sec": 2.7601085831411183,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4000fe3fb26ef207",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 60,
+ "epochs": 40,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_60p_40e_fixed_budget_seed74_82b4a6209e9c",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 75,
+ "n_particles": 60,
+ "epochs": 40,
+ "particle_epochs": 2400,
+ "train_loss": 1.23734712600708,
+ "train_acc": 0.6150000095367432,
+ "train_mse": 0.05402138829231262,
+ "test_loss": 1.6433888673782349,
+ "test_acc": 0.47200000286102295,
+ "test_mse": 0.07071221619844437,
+ "fit_time_sec": 2.791566374944523,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0966039f5ef7af88",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 60,
+ "epochs": 40,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_60p_40e_fixed_budget_seed75_0e2719972bac",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 71,
+ "n_particles": 90,
+ "epochs": 27,
+ "particle_epochs": 2430,
+ "train_loss": 1.454797387123108,
+ "train_acc": 0.5099999904632568,
+ "train_mse": 0.06346537172794342,
+ "test_loss": 1.7139235734939575,
+ "test_acc": 0.40400001406669617,
+ "test_mse": 0.07408219575881958,
+ "fit_time_sec": 3.001450875075534,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0777bd52fd76272d",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 90,
+ "epochs": 27,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_90p_27e_fixed_budget_seed71_83befaf31a59",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 72,
+ "n_particles": 90,
+ "epochs": 27,
+ "particle_epochs": 2430,
+ "train_loss": 1.436651349067688,
+ "train_acc": 0.5364999771118164,
+ "train_mse": 0.06031753495335579,
+ "test_loss": 1.525922417640686,
+ "test_acc": 0.5180000066757202,
+ "test_mse": 0.06329239904880524,
+ "fit_time_sec": 2.9281624578870833,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 90,
+ "epochs": 27,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_90p_27e_fixed_budget_seed72_cee00ffedfe8",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 73,
+ "n_particles": 90,
+ "epochs": 27,
+ "particle_epochs": 2430,
+ "train_loss": 1.5700972080230713,
+ "train_acc": 0.4805000126361847,
+ "train_mse": 0.06833409518003464,
+ "test_loss": 1.7064924240112305,
+ "test_acc": 0.4180000126361847,
+ "test_mse": 0.07409033179283142,
+ "fit_time_sec": 3.446030291961506,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2e6c351372592f10",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 90,
+ "epochs": 27,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_90p_27e_fixed_budget_seed73_63586637441d",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 74,
+ "n_particles": 90,
+ "epochs": 27,
+ "particle_epochs": 2430,
+ "train_loss": 1.4872608184814453,
+ "train_acc": 0.5425000190734863,
+ "train_mse": 0.06152648106217384,
+ "test_loss": 1.6065630912780762,
+ "test_acc": 0.5059999823570251,
+ "test_mse": 0.06642712652683258,
+ "fit_time_sec": 3.13685941696167,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4000fe3fb26ef207",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 90,
+ "epochs": 27,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_90p_27e_fixed_budget_seed74_3a58c7518a8f",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 75,
+ "n_particles": 90,
+ "epochs": 27,
+ "particle_epochs": 2430,
+ "train_loss": 1.4402897357940674,
+ "train_acc": 0.5699999928474426,
+ "train_mse": 0.05947257950901985,
+ "test_loss": 1.5009552240371704,
+ "test_acc": 0.5450000166893005,
+ "test_mse": 0.06177634745836258,
+ "fit_time_sec": 3.0350140419322997,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0966039f5ef7af88",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 90,
+ "epochs": 27,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_90p_27e_fixed_budget_seed75_c5c127ef9782",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 71,
+ "n_particles": 120,
+ "epochs": 20,
+ "particle_epochs": 2400,
+ "train_loss": 1.5967158079147339,
+ "train_acc": 0.4830000102519989,
+ "train_mse": 0.0660470575094223,
+ "test_loss": 1.7100492715835571,
+ "test_acc": 0.43799999356269836,
+ "test_mse": 0.07075551897287369,
+ "fit_time_sec": 3.14462749985978,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0777bd52fd76272d",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 20,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_20e_fixed_budget_seed71_c981e6c91251",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 72,
+ "n_particles": 120,
+ "epochs": 20,
+ "particle_epochs": 2400,
+ "train_loss": 1.673862338066101,
+ "train_acc": 0.46149998903274536,
+ "train_mse": 0.0692000463604927,
+ "test_loss": 1.8141505718231201,
+ "test_acc": 0.4099999964237213,
+ "test_mse": 0.07267315685749054,
+ "fit_time_sec": 3.102293625008315,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "6fcb6e473bdacbd2",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 20,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_20e_fixed_budget_seed72_331e9b3a3cb3",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 73,
+ "n_particles": 120,
+ "epochs": 20,
+ "particle_epochs": 2400,
+ "train_loss": 1.7135908603668213,
+ "train_acc": 0.4449999928474426,
+ "train_mse": 0.07240503281354904,
+ "test_loss": 1.8838708400726318,
+ "test_acc": 0.375,
+ "test_mse": 0.0778227150440216,
+ "fit_time_sec": 2.7550693340599537,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "2e6c351372592f10",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 20,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_20e_fixed_budget_seed73_06252d151e7b",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 74,
+ "n_particles": 120,
+ "epochs": 20,
+ "particle_epochs": 2400,
+ "train_loss": 1.5981744527816772,
+ "train_acc": 0.49950000643730164,
+ "train_mse": 0.06673180311918259,
+ "test_loss": 1.7434691190719604,
+ "test_acc": 0.42399999499320984,
+ "test_mse": 0.07240629941225052,
+ "fit_time_sec": 2.9445771670434624,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "4000fe3fb26ef207",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 20,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_20e_fixed_budget_seed74_b9a368cfca5a",
+ "regimen": "fixed_budget"
+ },
+ {
+ "protocol_version": "1.0.0",
+ "pso_version": "4.0.0",
+ "torch_version": "2.13.0",
+ "hardware": {
+ "platform": "macOS-26.5.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": 2,
+ "error": null,
+ "phase": "scaling",
+ "method": "adaptive_moment",
+ "candidate_label": "am_b0.06_s0.5",
+ "seed": 75,
+ "n_particles": 120,
+ "epochs": 20,
+ "particle_epochs": 2400,
+ "train_loss": 1.635738730430603,
+ "train_acc": 0.46950000524520874,
+ "train_mse": 0.06960180401802063,
+ "test_loss": 1.8486356735229492,
+ "test_acc": 0.4059999883174896,
+ "test_mse": 0.07580890506505966,
+ "fit_time_sec": 3.1960245410446078,
+ "data_fingerprint": "dfe645918ece54c0",
+ "model_fingerprint": "0966039f5ef7af88",
+ "device": "mps",
+ "completed": true,
+ "plugins": {
+ "movement": {
+ "title": "Adaptive Path-Moment PSO",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "moment_blend": 0.06,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ "moment_step_size": 0.5,
+ "moment_epsilon": 1e-08
+ }
+ },
+ "initialization": {
+ "title": "Model Weight + Uniform Noise Initialization",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {
+ "noise": 0.05
+ }
+ },
+ "evaluation": {
+ "title": "Fixed Subset Evaluation",
+ "source": null,
+ "fidelity": "experimental",
+ "gradient_required": false,
+ "options": {
+ "fitness_size": 2000
+ }
+ },
+ "convergence": {
+ "title": "No Convergence Action",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ },
+ "refinement": {
+ "title": "No Refinement",
+ "source": null,
+ "fidelity": "canonical",
+ "gradient_required": false,
+ "options": {}
+ }
+ },
+ "config": {
+ "method": "adaptive_moment",
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "negative_swarm": 0.0,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "convergence": "none",
+ "refinement": "none",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "method_options": {
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9
+ },
+ "n_particles": 120,
+ "epochs": 20,
+ "batch_size": 1000,
+ "renewal": "loss"
+ },
+ "run_id": "scaling_120p_20e_fixed_budget_seed75_177edb72bac0",
+ "regimen": "fixed_budget"
+ }
+ ]
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v4_tuning_confirmation.csv b/benchmark_results/pso_v4_tuning_confirmation.csv
new file mode 100644
index 0000000..0d43d14
--- /dev/null
+++ b/benchmark_results/pso_v4_tuning_confirmation.csv
@@ -0,0 +1,26 @@
+method,candidate_label,seed,n_particles,epochs,particle_epochs,train_loss,train_acc,test_loss,test_acc,test_mse,fit_time_sec,data_fingerprint,model_fingerprint,device
+adaptive_moment,am_b0.06_s0.5,61,30,80,2400,1.0297304391860962,0.6644999980926514,1.2476433515548706,0.5960000157356262,0.054337989538908005,3.3018275420181453,dfe645918ece54c0,2a1760dc9ec95c0a,mps
+adaptive_moment,am_b0.06_s0.5,62,30,80,2400,1.0248669385910034,0.6800000071525574,1.2172735929489136,0.6150000095367432,0.05301284044981003,3.082969541894272,dfe645918ece54c0,8722b0d78b78d382,mps
+adaptive_moment,am_b0.06_s0.5,63,30,80,2400,1.0421160459518433,0.6690000295639038,1.2344101667404175,0.6190000176429749,0.052518151700496674,2.7472599998582155,dfe645918ece54c0,f9f62f1942f9151e,mps
+adaptive_moment,am_b0.06_s0.5,64,30,80,2400,0.9773346185684204,0.7059999704360962,1.1978241205215454,0.6150000095367432,0.052042748779058456,2.670909541891888,dfe645918ece54c0,4cd40d38555ee5ce,mps
+adaptive_moment,am_b0.06_s0.5,65,30,80,2400,1.0047204494476318,0.6959999799728394,1.2509828805923462,0.6079999804496765,0.05341806635260582,2.9130489169619977,dfe645918ece54c0,70f99d26e1303b76,mps
+inertia,inertia_asymmetric,61,30,80,2400,1.0274338722229004,0.6735000014305115,1.2075469493865967,0.6320000290870667,0.051997773349285126,2.564156916923821,dfe645918ece54c0,2a1760dc9ec95c0a,mps
+inertia,inertia_asymmetric,62,30,80,2400,0.9986715912818909,0.6855000257492065,1.2740414142608643,0.578000009059906,0.056466199457645416,2.5913295838981867,dfe645918ece54c0,8722b0d78b78d382,mps
+inertia,inertia_asymmetric,63,30,80,2400,0.8828525543212891,0.7315000295639038,1.0797629356384277,0.6620000004768372,0.04682194069027901,2.6188287080731243,dfe645918ece54c0,f9f62f1942f9151e,mps
+inertia,inertia_asymmetric,64,30,80,2400,0.9942940473556519,0.6865000128746033,1.2426005601882935,0.621999979019165,0.05173056200146675,2.534188667079434,dfe645918ece54c0,4cd40d38555ee5ce,mps
+inertia,inertia_asymmetric,65,30,80,2400,1.0921698808670044,0.6729999780654907,1.2609055042266846,0.6209999918937683,0.052379049360752106,2.542070833966136,dfe645918ece54c0,70f99d26e1303b76,mps
+constriction,constriction_c205_canonical,61,30,80,2400,1.0248574018478394,0.6919999718666077,1.2035431861877441,0.6299999952316284,0.05152203515172005,2.5165979999583215,dfe645918ece54c0,2a1760dc9ec95c0a,mps
+constriction,constriction_c205_canonical,62,30,80,2400,1.1310851573944092,0.6700000166893005,1.3196481466293335,0.5849999785423279,0.055950723588466644,2.481917541939765,dfe645918ece54c0,8722b0d78b78d382,mps
+constriction,constriction_c205_canonical,63,30,80,2400,1.0529502630233765,0.6644999980926514,1.2498247623443604,0.5789999961853027,0.05548400804400444,2.593008500058204,dfe645918ece54c0,f9f62f1942f9151e,mps
+constriction,constriction_c205_canonical,64,30,80,2400,0.9444444179534912,0.7145000100135803,1.2384077310562134,0.6179999709129333,0.0526747927069664,2.4862103750929236,dfe645918ece54c0,4cd40d38555ee5ce,mps
+constriction,constriction_c205_canonical,65,30,80,2400,0.9420643448829651,0.7105000019073486,1.219950795173645,0.6209999918937683,0.051569391041994095,2.5256920421961695,dfe645918ece54c0,70f99d26e1303b76,mps
+local_best,local_best_r4_constant,61,30,80,2400,1.0233083963394165,0.703499972820282,1.1751943826675415,0.6549999713897705,0.050412945449352264,2.535716458922252,dfe645918ece54c0,2a1760dc9ec95c0a,mps
+local_best,local_best_r4_constant,62,30,80,2400,1.0379226207733154,0.6970000267028809,1.2656233310699463,0.593999981880188,0.056342579424381256,2.5843862500041723,dfe645918ece54c0,8722b0d78b78d382,mps
+local_best,local_best_r4_constant,63,30,80,2400,0.9664440751075745,0.7275000214576721,1.167758584022522,0.6570000052452087,0.049540925770998,2.485073500080034,dfe645918ece54c0,f9f62f1942f9151e,mps
+local_best,local_best_r4_constant,64,30,80,2400,1.0115971565246582,0.703000009059906,1.1620168685913086,0.625,0.052118122577667236,2.467889874940738,dfe645918ece54c0,4cd40d38555ee5ce,mps
+local_best,local_best_r4_constant,65,30,80,2400,1.0574767589569092,0.6959999799728394,1.286249041557312,0.6010000109672546,0.05573433265089989,2.488020292017609,dfe645918ece54c0,70f99d26e1303b76,mps
+quantum,quantum_beta_0.4_0.9,61,30,80,2400,1.4583405256271362,0.5460000038146973,1.464557409286499,0.5320000052452087,0.06282258033752441,2.3820620418991894,dfe645918ece54c0,2a1760dc9ec95c0a,mps
+quantum,quantum_beta_0.4_0.9,62,30,80,2400,1.5153175592422485,0.5084999799728394,1.5834708213806152,0.4650000035762787,0.0668596550822258,2.4394417498260736,dfe645918ece54c0,8722b0d78b78d382,mps
+quantum,quantum_beta_0.4_0.9,63,30,80,2400,1.4202407598495483,0.5490000247955322,1.5065674781799316,0.4860000014305115,0.06405868381261826,2.3948492500931025,dfe645918ece54c0,f9f62f1942f9151e,mps
+quantum,quantum_beta_0.4_0.9,64,30,80,2400,1.3938108682632446,0.5199999809265137,1.4775264263153076,0.46799999475479126,0.06637361645698547,2.3948124169837683,dfe645918ece54c0,4cd40d38555ee5ce,mps
+quantum,quantum_beta_0.4_0.9,65,30,80,2400,1.3520328998565674,0.5724999904632568,1.5641074180603027,0.4779999852180481,0.06454122811555862,2.402772541856393,dfe645918ece54c0,70f99d26e1303b76,mps
diff --git a/benchmark_results/pso_v4_tuning_search.csv b/benchmark_results/pso_v4_tuning_search.csv
new file mode 100644
index 0000000..91afc6d
--- /dev/null
+++ b/benchmark_results/pso_v4_tuning_search.csv
@@ -0,0 +1,97 @@
+method,candidate_label,seed,n_particles,epochs,particle_epochs,train_loss,train_acc,val_loss,val_acc,val_mse,fit_time_sec,data_fingerprint,model_fingerprint,device
+adaptive_moment,am_b0.03_s0.5,51,30,80,2400,1.112807035446167,0.6570000052452087,1.0964455604553223,0.6633333563804626,0.046677425503730774,2.5230953749269247,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.03_s0.5,52,30,80,2400,0.995387077331543,0.6869999766349792,1.0115970373153687,0.6816666722297668,0.04280940815806389,2.5447300830855966,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.03_s0.5,53,30,80,2400,0.9480092525482178,0.7080000042915344,0.9940392971038818,0.6883333325386047,0.0421285405755043,2.493663167115301,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.03_s1.0,51,30,80,2400,0.9984938502311707,0.7024999856948853,1.0240328311920166,0.6850000023841858,0.04404553398489952,2.54264641716145,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.03_s1.0,52,30,80,2400,1.0163198709487915,0.6890000104904175,0.9720749855041504,0.6933333277702332,0.042471032589673996,2.491340707987547,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.03_s1.0,53,30,80,2400,1.0211265087127686,0.6884999871253967,1.081996202468872,0.6850000023841858,0.04483034089207649,2.633713499875739,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.03_s1.5,51,30,80,2400,1.0612047910690308,0.6735000014305115,1.030881404876709,0.6850000023841858,0.04405777156352997,2.8367540831677616,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.03_s1.5,52,30,80,2400,0.9462777972221375,0.7149999737739563,0.8990310430526733,0.7266666889190674,0.03923330828547478,2.5477614579722285,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.03_s1.5,53,30,80,2400,0.9608960747718811,0.7120000123977661,1.0034033060073853,0.6833333373069763,0.042279649525880814,2.5643632498104125,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.06_s0.5,51,30,80,2400,1.068866491317749,0.6855000257492065,1.0220483541488647,0.675000011920929,0.04446922242641449,2.6285997920203954,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.06_s0.5,52,30,80,2400,0.9650915265083313,0.7080000042915344,0.9152445197105408,0.7083333134651184,0.04066821560263634,2.7918378338217735,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.06_s0.5,53,30,80,2400,0.9414446949958801,0.7014999985694885,0.9156243801116943,0.721666693687439,0.03982962667942047,2.729898874880746,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.06_s1.0,51,30,80,2400,1.0662047863006592,0.6754999756813049,0.9721739888191223,0.6899999976158142,0.042344048619270325,2.5812953328713775,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.06_s1.0,52,30,80,2400,0.9808334112167358,0.6924999952316284,0.9488086104393005,0.6933333277702332,0.04174558073282242,2.8018474159762263,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.06_s1.0,53,30,80,2400,0.9464473724365234,0.7085000276565552,0.9320653080940247,0.7083333134651184,0.040938157588243484,2.7171109160408378,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.06_s1.5,51,30,80,2400,1.1136488914489746,0.6549999713897705,1.1235008239746094,0.6650000214576721,0.04781530797481537,2.7500752080231905,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.06_s1.5,52,30,80,2400,1.0324392318725586,0.6825000047683716,1.0213521718978882,0.6833333373069763,0.04513593390583992,3.103288209065795,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.06_s1.5,53,30,80,2400,1.0860146284103394,0.6589999794960022,1.0920277833938599,0.6499999761581421,0.04753243178129196,2.862214791122824,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.1_s0.5,51,30,80,2400,1.0369712114334106,0.6644999980926514,1.0877516269683838,0.6766666769981384,0.04590357467532158,2.8528131251223385,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.1_s0.5,52,30,80,2400,0.9936539530754089,0.6965000033378601,0.9451570510864258,0.6983333230018616,0.040929101407527924,2.7851123749278486,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.1_s0.5,53,30,80,2400,0.9365023374557495,0.7014999985694885,0.8658249974250793,0.7283333539962769,0.038747914135456085,2.7191387079656124,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.1_s1.0,51,30,80,2400,1.0722532272338867,0.6995000243186951,0.9926102757453918,0.7016666531562805,0.04247405380010605,2.8380547501146793,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.1_s1.0,52,30,80,2400,0.9977437853813171,0.6930000185966492,1.009635329246521,0.6966666579246521,0.04288069158792496,2.905045999912545,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.1_s1.0,53,30,80,2400,1.0425642728805542,0.6664999723434448,1.0561128854751587,0.6783333420753479,0.0449373684823513,2.7804793331306428,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.1_s1.5,51,30,80,2400,1.0099478960037231,0.6775000095367432,1.00997793674469,0.6899999976158142,0.042956266552209854,2.8892802079208195,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.1_s1.5,52,30,80,2400,1.0597009658813477,0.6744999885559082,1.063821792602539,0.6966666579246521,0.044883932918310165,2.669369083130732,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.1_s1.5,53,30,80,2400,0.986152708530426,0.7080000042915344,1.0491483211517334,0.6850000023841858,0.04293783754110336,2.626303083030507,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.15_s0.5,51,30,80,2400,1.1084171533584595,0.652999997138977,1.1322306394577026,0.6600000262260437,0.04928039386868477,2.5766194579191506,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.15_s0.5,52,30,80,2400,0.970059335231781,0.7129999995231628,0.9312149882316589,0.7300000190734863,0.03986109420657158,2.731992583023384,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.15_s0.5,53,30,80,2400,0.9970248341560364,0.6995000243186951,0.9656715989112854,0.70333331823349,0.04226723685860634,3.0274115409702063,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.15_s1.0,51,30,80,2400,1.0099536180496216,0.7009999752044678,0.9564719796180725,0.7166666388511658,0.04047820717096329,2.9793542500119656,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.15_s1.0,52,30,80,2400,1.0434995889663696,0.6819999814033508,0.9963273406028748,0.6949999928474426,0.04349374398589134,2.8151185419410467,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.15_s1.0,53,30,80,2400,1.0348174571990967,0.6840000152587891,1.0127019882202148,0.6866666674613953,0.04363732784986496,3.0412363330833614,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.15_s1.5,51,30,80,2400,1.1573493480682373,0.6299999952316284,1.2029211521148682,0.6133333444595337,0.05152761936187744,3.1714885828550905,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.15_s1.5,52,30,80,2400,1.060623288154602,0.6949999928474426,1.0831577777862549,0.6966666579246521,0.04344262182712555,2.993674041936174,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.15_s1.5,53,30,80,2400,1.0753278732299805,0.6769999861717224,0.9602290987968445,0.6983333230018616,0.0414869599044323,2.7658886671997607,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.06_s1.0_beta0.8,51,30,80,2400,1.1594665050506592,0.6480000019073486,1.1239941120147705,0.6700000166893005,0.047122661024332047,2.764871333958581,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.06_s1.0_beta0.8,52,30,80,2400,0.9945915341377258,0.7064999938011169,1.0324488878250122,0.6683333516120911,0.04436164349317551,2.830462665995583,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.06_s1.0_beta0.8,53,30,80,2400,0.9297089576721191,0.7110000252723694,0.938503623008728,0.70333331823349,0.04101715609431267,2.8122877080459148,bfc8de485755d7f3,00868f788440b8a0,mps
+adaptive_moment,am_b0.06_s1.0_beta0.95,51,30,80,2400,1.1143780946731567,0.6514999866485596,1.0093973875045776,0.6800000071525574,0.04380199685692787,2.9217382080387324,bfc8de485755d7f3,82b3214d02e2e634,mps
+adaptive_moment,am_b0.06_s1.0_beta0.95,52,30,80,2400,1.0144661664962769,0.6884999871253967,0.9828318357467651,0.6833333373069763,0.04375388100743294,2.777603624854237,bfc8de485755d7f3,ddffbe335bef15ad,mps
+adaptive_moment,am_b0.06_s1.0_beta0.95,53,30,80,2400,1.1004270315170288,0.6600000262260437,1.0834088325500488,0.6683333516120911,0.04595582187175751,3.0502532080281526,bfc8de485755d7f3,00868f788440b8a0,mps
+inertia,inertia_canonical,51,30,80,2400,1.4416260719299316,0.5649999976158142,1.4125466346740723,0.6000000238418579,0.05729174241423607,3.098805333022028,bfc8de485755d7f3,82b3214d02e2e634,mps
+inertia,inertia_canonical,52,30,80,2400,1.665074348449707,0.4894999861717224,1.6294100284576416,0.5066666603088379,0.06497763097286224,2.652766958111897,bfc8de485755d7f3,ddffbe335bef15ad,mps
+inertia,inertia_canonical,53,30,80,2400,1.4698249101638794,0.5565000176429749,1.4316622018814087,0.5683333277702332,0.059196680784225464,2.529014667030424,bfc8de485755d7f3,00868f788440b8a0,mps
+inertia,inertia_tuned,51,30,80,2400,1.0468239784240723,0.699999988079071,1.0345858335494995,0.6816666722297668,0.04465937986969948,2.626064541982487,bfc8de485755d7f3,82b3214d02e2e634,mps
+inertia,inertia_tuned,52,30,80,2400,0.9420707821846008,0.703000009059906,0.9224241375923157,0.7250000238418579,0.040230974555015564,2.5009557919111103,bfc8de485755d7f3,ddffbe335bef15ad,mps
+inertia,inertia_tuned,53,30,80,2400,1.0711344480514526,0.6754999756813049,1.0678696632385254,0.6766666769981384,0.04436859115958214,2.4420957090333104,bfc8de485755d7f3,00868f788440b8a0,mps
+inertia,inertia_low_w,51,30,80,2400,1.113174319267273,0.6365000009536743,1.0575727224349976,0.6850000023841858,0.0461583249270916,2.484879707917571,bfc8de485755d7f3,82b3214d02e2e634,mps
+inertia,inertia_low_w,52,30,80,2400,1.0245047807693481,0.6790000200271606,0.9806669354438782,0.70333331823349,0.042586930096149445,2.643615792039782,bfc8de485755d7f3,ddffbe335bef15ad,mps
+inertia,inertia_low_w,53,30,80,2400,1.0131726264953613,0.6859999895095825,0.9656168818473816,0.6983333230018616,0.04216707497835159,2.4834530411753803,bfc8de485755d7f3,00868f788440b8a0,mps
+inertia,inertia_w_decay,51,30,80,2400,1.0393675565719604,0.6915000081062317,1.025821566581726,0.6983333230018616,0.04372088611125946,2.426888459129259,bfc8de485755d7f3,82b3214d02e2e634,mps
+inertia,inertia_w_decay,52,30,80,2400,1.1047112941741943,0.6600000262260437,1.1661359071731567,0.6700000166893005,0.04753515496850014,2.480164624983445,bfc8de485755d7f3,ddffbe335bef15ad,mps
+inertia,inertia_w_decay,53,30,80,2400,0.9673198461532593,0.6909999847412109,0.9870904684066772,0.6816666722297668,0.04321449622511864,2.422041916055605,bfc8de485755d7f3,00868f788440b8a0,mps
+inertia,inertia_asymmetric,51,30,80,2400,1.0810083150863647,0.6775000095367432,1.0954482555389404,0.6949999928474426,0.04539918154478073,2.485565959010273,bfc8de485755d7f3,82b3214d02e2e634,mps
+inertia,inertia_asymmetric,52,30,80,2400,0.9861184358596802,0.6909999847412109,1.0121054649353027,0.6933333277702332,0.043754804879426956,2.5209125420078635,bfc8de485755d7f3,ddffbe335bef15ad,mps
+inertia,inertia_asymmetric,53,30,80,2400,0.9526417851448059,0.722000002861023,0.9798429608345032,0.70333331823349,0.04217696189880371,2.5959840829018503,bfc8de485755d7f3,00868f788440b8a0,mps
+constriction,constriction_c201,51,30,80,2400,1.0345860719680786,0.6869999766349792,0.9738073945045471,0.6916666626930237,0.042279358953237534,2.698073250008747,bfc8de485755d7f3,82b3214d02e2e634,mps
+constriction,constriction_c201,52,30,80,2400,1.0233638286590576,0.6865000128746033,1.0523117780685425,0.6883333325386047,0.043930795043706894,3.4117308750282973,bfc8de485755d7f3,ddffbe335bef15ad,mps
+constriction,constriction_c201,53,30,80,2400,1.0302053689956665,0.6880000233650208,0.9275049567222595,0.7166666388511658,0.040264155715703964,3.1805959579069167,bfc8de485755d7f3,00868f788440b8a0,mps
+constriction,constriction_c205_canonical,51,30,80,2400,1.0515944957733154,0.6759999990463257,1.0619410276412964,0.6933333277702332,0.044216156005859375,3.237764042103663,bfc8de485755d7f3,82b3214d02e2e634,mps
+constriction,constriction_c205_canonical,52,30,80,2400,1.061699390411377,0.6744999885559082,1.016150712966919,0.6866666674613953,0.0442710816860199,2.7161605830769986,bfc8de485755d7f3,ddffbe335bef15ad,mps
+constriction,constriction_c205_canonical,53,30,80,2400,0.9327093362808228,0.7289999723434448,0.8751127123832703,0.746666669845581,0.03667077049612999,2.968678707955405,bfc8de485755d7f3,00868f788440b8a0,mps
+constriction,constriction_c205_tuned,51,30,80,2400,1.053567886352539,0.6825000047683716,0.991266667842865,0.699999988079071,0.04196731001138687,3.042221749899909,bfc8de485755d7f3,82b3214d02e2e634,mps
+constriction,constriction_c205_tuned,52,30,80,2400,0.9388713836669922,0.7139999866485596,0.9303705096244812,0.7116666436195374,0.0403158962726593,2.8448961251415312,bfc8de485755d7f3,ddffbe335bef15ad,mps
+constriction,constriction_c205_tuned,53,30,80,2400,0.9965179562568665,0.6995000243186951,0.9846652150154114,0.7133333086967468,0.04187808558344841,3.1848887908272445,bfc8de485755d7f3,00868f788440b8a0,mps
+constriction,constriction_c250,51,30,80,2400,2.2795634269714355,0.18150000274181366,2.250452756881714,0.18666666746139526,0.08861013501882553,2.9961123750545084,bfc8de485755d7f3,82b3214d02e2e634,mps
+constriction,constriction_c250,52,30,80,2400,2.2547407150268555,0.20350000262260437,2.2187206745147705,0.2150000035762787,0.08802558481693268,3.024313250090927,bfc8de485755d7f3,ddffbe335bef15ad,mps
+constriction,constriction_c250,53,30,80,2400,2.19023060798645,0.19300000369548798,2.178219795227051,0.20499999821186066,0.08775272965431213,2.961929291021079,bfc8de485755d7f3,00868f788440b8a0,mps
+constriction,constriction_asymmetric,51,30,80,2400,1.2645200490951538,0.6150000095367432,1.2170491218566895,0.6316666603088379,0.05265685170888901,3.023697500117123,bfc8de485755d7f3,82b3214d02e2e634,mps
+constriction,constriction_asymmetric,52,30,80,2400,1.2607256174087524,0.6014999747276306,1.2684078216552734,0.5883333086967468,0.05453150346875191,2.8057189998216927,bfc8de485755d7f3,ddffbe335bef15ad,mps
+constriction,constriction_asymmetric,53,30,80,2400,1.2320771217346191,0.6140000224113464,1.2376829385757446,0.6200000047683716,0.05186690762639046,2.709051915910095,bfc8de485755d7f3,00868f788440b8a0,mps
+local_best,local_best_r1_constant,51,30,80,2400,1.4435429573059082,0.5354999899864197,1.4319947957992554,0.528333306312561,0.062414027750492096,2.6544057081919163,bfc8de485755d7f3,82b3214d02e2e634,mps
+local_best,local_best_r1_constant,52,30,80,2400,1.4914970397949219,0.527999997138977,1.4473850727081299,0.5333333611488342,0.06336859613656998,2.7407990000210702,bfc8de485755d7f3,ddffbe335bef15ad,mps
+local_best,local_best_r1_constant,53,30,80,2400,1.4734760522842407,0.5680000185966492,1.5045198202133179,0.5366666913032532,0.06426934152841568,2.693694499786943,bfc8de485755d7f3,00868f788440b8a0,mps
+local_best,local_best_r2_constant,51,30,80,2400,1.2284750938415527,0.6345000267028809,1.191932201385498,0.628333330154419,0.0514327734708786,2.4563205409795046,bfc8de485755d7f3,82b3214d02e2e634,mps
+local_best,local_best_r2_constant,52,30,80,2400,1.1704559326171875,0.6504999995231628,1.1325551271438599,0.6700000166893005,0.049076274037361145,2.5833707919809967,bfc8de485755d7f3,ddffbe335bef15ad,mps
+local_best,local_best_r2_constant,53,30,80,2400,1.243313193321228,0.6320000290870667,1.2125868797302246,0.6516666412353516,0.05214923247694969,2.475700625218451,bfc8de485755d7f3,00868f788440b8a0,mps
+local_best,local_best_r4_constant,51,30,80,2400,1.0172255039215088,0.6884999871253967,1.0000126361846924,0.699999988079071,0.0425647497177124,2.4682277080137283,bfc8de485755d7f3,82b3214d02e2e634,mps
+local_best,local_best_r4_constant,52,30,80,2400,0.9992414712905884,0.7089999914169312,0.9295963644981384,0.7283333539962769,0.04094172641634941,2.4259307920001447,bfc8de485755d7f3,ddffbe335bef15ad,mps
+local_best,local_best_r4_constant,53,30,80,2400,0.9578440189361572,0.7139999866485596,0.9051287770271301,0.7450000047683716,0.03751235082745552,2.4171505419071764,bfc8de485755d7f3,00868f788440b8a0,mps
+local_best,local_best_r1_decay,51,30,80,2400,1.4906078577041626,0.5640000104904175,1.4867504835128784,0.5400000214576721,0.06405453383922577,2.455931582953781,bfc8de485755d7f3,82b3214d02e2e634,mps
+local_best,local_best_r1_decay,52,30,80,2400,1.4803287982940674,0.5559999942779541,1.4699759483337402,0.5733333230018616,0.0630197748541832,2.5800107079558074,bfc8de485755d7f3,ddffbe335bef15ad,mps
+local_best,local_best_r1_decay,53,30,80,2400,1.4953768253326416,0.5370000004768372,1.4344968795776367,0.5416666865348816,0.06267009675502777,2.5192452499177307,bfc8de485755d7f3,00868f788440b8a0,mps
+quantum,quantum_beta_0.5_1.0,51,30,80,2400,1.4666624069213867,0.5055000185966492,1.4257338047027588,0.5183333158493042,0.06076965853571892,2.411743083037436,bfc8de485755d7f3,82b3214d02e2e634,mps
+quantum,quantum_beta_0.5_1.0,52,30,80,2400,1.4086458683013916,0.5370000004768372,1.3660792112350464,0.5383333563804626,0.05962810665369034,2.398069208022207,bfc8de485755d7f3,ddffbe335bef15ad,mps
+quantum,quantum_beta_0.5_1.0,53,30,80,2400,1.3147938251495361,0.5580000281333923,1.295978307723999,0.574999988079071,0.05797567218542099,2.4090406668838114,bfc8de485755d7f3,00868f788440b8a0,mps
+quantum,quantum_beta_0.6_1.0,51,30,80,2400,1.7944316864013672,0.3955000042915344,1.7316218614578247,0.4050000011920929,0.07277336716651917,2.4751413341145962,bfc8de485755d7f3,82b3214d02e2e634,mps
+quantum,quantum_beta_0.6_1.0,52,30,80,2400,1.770385980606079,0.3785000145435333,1.7482523918151855,0.3866666555404663,0.07508829981088638,2.41624170797877,bfc8de485755d7f3,ddffbe335bef15ad,mps
+quantum,quantum_beta_0.6_1.0,53,30,80,2400,1.711459994316101,0.4320000112056732,1.684290885925293,0.4399999976158142,0.07037489116191864,2.4244089999701828,bfc8de485755d7f3,00868f788440b8a0,mps
+quantum,quantum_beta_0.5_1.2,51,30,80,2400,1.6640392541885376,0.4580000042915344,1.6313401460647583,0.43833333253860474,0.0688972994685173,2.379183917073533,bfc8de485755d7f3,82b3214d02e2e634,mps
+quantum,quantum_beta_0.5_1.2,52,30,80,2400,1.5431870222091675,0.49149999022483826,1.515285849571228,0.5133333206176758,0.06496633589267731,2.3730562501586974,bfc8de485755d7f3,ddffbe335bef15ad,mps
+quantum,quantum_beta_0.5_1.2,53,30,80,2400,1.7410157918930054,0.4059999883174896,1.7098183631896973,0.3916666805744171,0.07386184483766556,2.438973000040278,bfc8de485755d7f3,00868f788440b8a0,mps
+quantum,quantum_beta_0.4_0.9,51,30,80,2400,1.4330989122390747,0.512499988079071,1.369968295097351,0.5433333516120911,0.06111948564648628,2.5881015001796186,bfc8de485755d7f3,82b3214d02e2e634,mps
+quantum,quantum_beta_0.4_0.9,52,30,80,2400,1.4685417413711548,0.5249999761581421,1.3982360363006592,0.5716666579246521,0.06072157621383667,2.5672016669996083,bfc8de485755d7f3,ddffbe335bef15ad,mps
+quantum,quantum_beta_0.4_0.9,53,30,80,2400,1.3139362335205078,0.5789999961853027,1.244922161102295,0.5799999833106995,0.056043192744255066,2.4583064999897033,bfc8de485755d7f3,00868f788440b8a0,mps
diff --git a/benchmark_results/pso_v5_deep_methods.csv b/benchmark_results/pso_v5_deep_methods.csv
new file mode 100644
index 0000000..15fb758
--- /dev/null
+++ b/benchmark_results/pso_v5_deep_methods.csv
@@ -0,0 +1,10 @@
+section,metric,value
+protocol,version,MNIST-PSO-RAW-V5 1.0.0
+pilot,selected_dimension,full
+single_model,test_accuracy,83.23
+single_model,test_nll,0.556332
+single_model,test_brier,0.253921
+single_model,test_ece,0.085242
+ensemble,test_accuracy,87.0
+ensemble,test_nll,0.535928
+ensemble,pairwise_disagreement,0.1585
diff --git a/benchmark_results/pso_v5_deep_methods.json b/benchmark_results/pso_v5_deep_methods.json
new file mode 100644
index 0000000..e356327
--- /dev/null
+++ b/benchmark_results/pso_v5_deep_methods.json
@@ -0,0 +1,12850 @@
+{
+ "protocol_version": "MNIST-PSO-RAW-V5 1.0.0",
+ "pso_version": "4.0.0",
+ "timestamp": "2026-09-02T10:19:51.467879+00:00",
+ "completed": true,
+ "hardware_provenance": {
+ "platform": "macOS-26.6.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "data_provenance": {
+ "input_shape": [
+ 1,
+ 28,
+ 28
+ ],
+ "pca": false,
+ "raw_inputs": true,
+ "normalization_scope": "search_train_50000_only",
+ "train_mean": 0.130682,
+ "train_std": 0.308127,
+ "search_samples": 50000,
+ "val_samples": 10000,
+ "test_samples": 10000,
+ "split_seed": 20260902,
+ "split_fingerprint": "51b289d9f503a9f3"
+ },
+ "data_fingerprint": "5a383dfbf7c31442",
+ "base_model_fingerprint": "d0eee0ffd33088ed",
+ "configuration": {
+ "base_model_seed": 41,
+ "split_seed": 20260902,
+ "pilot_seed": 91,
+ "pilot_dimensions": [
+ "290",
+ "1024",
+ "4096",
+ "full"
+ ],
+ "pilot_particles": 30,
+ "pilot_epochs": 160,
+ "confirmation_seeds": [
+ 101,
+ 102,
+ 103
+ ],
+ "confirmation_particles": 60,
+ "confirmation_epochs": 600,
+ "confirmation_schedule": "2000:420,10000:135,50000:45",
+ "fitness_objective": "cross_entropy_loss_primary_accuracy_tiebreak",
+ "parameterization": {
+ "layer_scale": "per_parameter_tensor_std_floor_1e-4",
+ "subspace": "deterministic_sparse_signed_hash_count_normalized",
+ "initialization": "exact_base_plus_antithetic",
+ "initial_radius": 0.5,
+ "reflective_bound": 3.0
+ },
+ "movement": {
+ "name": "latent_adaptive_moment_pso",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w": 0.7298,
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999
+ },
+ "objective_transition": "reevaluate_all_pbests_then_rebuild_gbest",
+ "validation_selection": {
+ "single": "lowest_nll_then_highest_accuracy",
+ "ensemble": "within_2_accuracy_points_then_greedy_disagreement",
+ "ensemble_size": 5
+ },
+ "fitness_batch_size": 1000,
+ "ece_bins": 15
+ },
+ "pilot_phase": {
+ "selected_dimension": "full",
+ "results": [
+ {
+ "dimension": "290",
+ "val_loss": 2.216933,
+ "val_acc": 22.33,
+ "wall_time_sec": 6.0698,
+ "queries": 4800,
+ "sample_evaluations": 9600000
+ },
+ {
+ "dimension": "1024",
+ "val_loss": 1.960143,
+ "val_acc": 41.34,
+ "wall_time_sec": 6.0666,
+ "queries": 4800,
+ "sample_evaluations": 9600000
+ },
+ {
+ "dimension": "4096",
+ "val_loss": 1.550738,
+ "val_acc": 55.97,
+ "wall_time_sec": 6.2638,
+ "queries": 4800,
+ "sample_evaluations": 9600000
+ },
+ {
+ "dimension": "full",
+ "val_loss": 1.205564,
+ "val_acc": 67.18,
+ "wall_time_sec": 6.1629,
+ "queries": 4800,
+ "sample_evaluations": 9600000
+ }
+ ]
+ },
+ "confirmation_phase": {
+ "runs": [
+ {
+ "seed": 101,
+ "val_loss": 0.59828,
+ "val_acc": 81.96,
+ "wall_time_sec": 124.8601,
+ "queries": 36120,
+ "sample_evaluations": 270000000,
+ "transition_reevaluations": 120,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.313677,
+ "gbest_acc": 8.55
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.301218,
+ "gbest_acc": 8.3
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.285447,
+ "gbest_acc": 10.2
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.272852,
+ "gbest_acc": 10.25
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.25676,
+ "gbest_acc": 15.2
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.235169,
+ "gbest_acc": 16.05
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.215387,
+ "gbest_acc": 17.5
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.195138,
+ "gbest_acc": 16.95
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.172303,
+ "gbest_acc": 17.1
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.143942,
+ "gbest_acc": 18.4
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.104848,
+ "gbest_acc": 25.65
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.074167,
+ "gbest_acc": 28.2
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.047087,
+ "gbest_acc": 31.1
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.037421,
+ "gbest_acc": 31.6
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.020699,
+ "gbest_acc": 32.6
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.001263,
+ "gbest_acc": 31.6
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.987104,
+ "gbest_acc": 32.8
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.974485,
+ "gbest_acc": 34.5
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.95992,
+ "gbest_acc": 33.55
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.920345,
+ "gbest_acc": 35.7
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.89665,
+ "gbest_acc": 34.45
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.865372,
+ "gbest_acc": 37.95
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.862488,
+ "gbest_acc": 36.9
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.840315,
+ "gbest_acc": 37.5
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.80913,
+ "gbest_acc": 41.65
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.805179,
+ "gbest_acc": 41.25
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.790193,
+ "gbest_acc": 41.5
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.778837,
+ "gbest_acc": 42.0
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.741537,
+ "gbest_acc": 40.7
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.723342,
+ "gbest_acc": 41.95
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.723342,
+ "gbest_acc": 41.95
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.723342,
+ "gbest_acc": 41.95
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711093,
+ "gbest_acc": 44.2
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.710663,
+ "gbest_acc": 43.1
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.697524,
+ "gbest_acc": 47.95
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.695646,
+ "gbest_acc": 43.15
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675378,
+ "gbest_acc": 44.8
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675378,
+ "gbest_acc": 44.8
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675378,
+ "gbest_acc": 44.8
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675378,
+ "gbest_acc": 44.8
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.663723,
+ "gbest_acc": 47.1
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.643251,
+ "gbest_acc": 47.8
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.638515,
+ "gbest_acc": 49.0
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.638515,
+ "gbest_acc": 49.0
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.638515,
+ "gbest_acc": 49.0
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.630599,
+ "gbest_acc": 49.85
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.625831,
+ "gbest_acc": 49.35
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.612363,
+ "gbest_acc": 49.3
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.607309,
+ "gbest_acc": 49.15
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597507,
+ "gbest_acc": 49.95
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597507,
+ "gbest_acc": 49.95
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.589937,
+ "gbest_acc": 49.15
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585674,
+ "gbest_acc": 49.05
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585674,
+ "gbest_acc": 49.05
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581923,
+ "gbest_acc": 48.6
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.573042,
+ "gbest_acc": 50.3
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566593,
+ "gbest_acc": 50.35
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.560889,
+ "gbest_acc": 50.5
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.559696,
+ "gbest_acc": 51.85
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548405,
+ "gbest_acc": 50.6
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.533284,
+ "gbest_acc": 51.35
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.524202,
+ "gbest_acc": 52.7
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.516219,
+ "gbest_acc": 52.6
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.503177,
+ "gbest_acc": 53.55
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497524,
+ "gbest_acc": 53.6
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497524,
+ "gbest_acc": 53.6
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.480576,
+ "gbest_acc": 54.55
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.480576,
+ "gbest_acc": 54.55
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.480576,
+ "gbest_acc": 54.55
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.473511,
+ "gbest_acc": 56.2
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.465575,
+ "gbest_acc": 55.55
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.454523,
+ "gbest_acc": 57.35
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.450428,
+ "gbest_acc": 55.35
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.447881,
+ "gbest_acc": 54.65
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.447881,
+ "gbest_acc": 54.65
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.445152,
+ "gbest_acc": 55.2
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.434854,
+ "gbest_acc": 56.0
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.428277,
+ "gbest_acc": 54.7
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.42306,
+ "gbest_acc": 56.95
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.42306,
+ "gbest_acc": 56.95
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.420771,
+ "gbest_acc": 57.05
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401691,
+ "gbest_acc": 57.65
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401691,
+ "gbest_acc": 57.65
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401691,
+ "gbest_acc": 57.65
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401691,
+ "gbest_acc": 57.65
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401691,
+ "gbest_acc": 57.65
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388926,
+ "gbest_acc": 57.4
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.379302,
+ "gbest_acc": 57.65
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.367295,
+ "gbest_acc": 57.5
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.365037,
+ "gbest_acc": 57.15
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362138,
+ "gbest_acc": 57.8
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362138,
+ "gbest_acc": 57.8
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357383,
+ "gbest_acc": 59.7
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.351984,
+ "gbest_acc": 60.0
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.340514,
+ "gbest_acc": 60.05
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.339794,
+ "gbest_acc": 59.55
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.339794,
+ "gbest_acc": 59.55
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.337035,
+ "gbest_acc": 58.8
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.31557,
+ "gbest_acc": 60.75
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.307023,
+ "gbest_acc": 61.5
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.30571,
+ "gbest_acc": 61.2
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.296036,
+ "gbest_acc": 61.4
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.287034,
+ "gbest_acc": 60.8
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.274328,
+ "gbest_acc": 60.55
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.265965,
+ "gbest_acc": 61.2
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.265965,
+ "gbest_acc": 61.2
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.264671,
+ "gbest_acc": 60.55
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.256872,
+ "gbest_acc": 61.15
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.24565,
+ "gbest_acc": 60.9
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.24565,
+ "gbest_acc": 60.9
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.23394,
+ "gbest_acc": 61.75
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.229833,
+ "gbest_acc": 62.15
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.224336,
+ "gbest_acc": 63.0
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.222568,
+ "gbest_acc": 62.3
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.218483,
+ "gbest_acc": 62.95
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.218483,
+ "gbest_acc": 62.95
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.215361,
+ "gbest_acc": 63.05
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.215157,
+ "gbest_acc": 63.0
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.207,
+ "gbest_acc": 62.7
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.205241,
+ "gbest_acc": 62.6
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.202124,
+ "gbest_acc": 62.3
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.202124,
+ "gbest_acc": 62.3
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.202124,
+ "gbest_acc": 62.3
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.201801,
+ "gbest_acc": 62.75
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.198071,
+ "gbest_acc": 63.15
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.194383,
+ "gbest_acc": 63.15
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.185661,
+ "gbest_acc": 63.35
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.18259,
+ "gbest_acc": 62.95
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.180251,
+ "gbest_acc": 63.15
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.180251,
+ "gbest_acc": 63.15
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177119,
+ "gbest_acc": 63.7
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.173862,
+ "gbest_acc": 63.95
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.16776,
+ "gbest_acc": 64.15
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.165842,
+ "gbest_acc": 64.7
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.162118,
+ "gbest_acc": 64.45
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.160006,
+ "gbest_acc": 64.7
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.160006,
+ "gbest_acc": 64.7
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.159862,
+ "gbest_acc": 64.8
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.155164,
+ "gbest_acc": 64.3
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.151701,
+ "gbest_acc": 64.4
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.14994,
+ "gbest_acc": 64.6
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.141593,
+ "gbest_acc": 65.4
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.14009,
+ "gbest_acc": 65.0
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.138661,
+ "gbest_acc": 64.95
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.135054,
+ "gbest_acc": 64.85
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.13004,
+ "gbest_acc": 65.65
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.128534,
+ "gbest_acc": 65.3
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12762,
+ "gbest_acc": 65.15
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.121394,
+ "gbest_acc": 65.45
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.120281,
+ "gbest_acc": 65.45
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.114436,
+ "gbest_acc": 65.75
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.114319,
+ "gbest_acc": 65.9
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.107381,
+ "gbest_acc": 66.75
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.107381,
+ "gbest_acc": 66.75
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106943,
+ "gbest_acc": 66.7
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.102692,
+ "gbest_acc": 66.75
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.102692,
+ "gbest_acc": 66.75
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.102692,
+ "gbest_acc": 66.75
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.10121,
+ "gbest_acc": 66.2
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.097785,
+ "gbest_acc": 66.8
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.096515,
+ "gbest_acc": 66.2
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.091991,
+ "gbest_acc": 67.0
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.088765,
+ "gbest_acc": 66.0
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.088765,
+ "gbest_acc": 66.0
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.086473,
+ "gbest_acc": 66.15
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.085017,
+ "gbest_acc": 66.65
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.083735,
+ "gbest_acc": 66.7
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.076043,
+ "gbest_acc": 67.0
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.071561,
+ "gbest_acc": 67.9
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.071561,
+ "gbest_acc": 67.9
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.071561,
+ "gbest_acc": 67.9
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.071561,
+ "gbest_acc": 67.9
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.071561,
+ "gbest_acc": 67.9
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.070564,
+ "gbest_acc": 67.8
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.069207,
+ "gbest_acc": 67.9
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.064575,
+ "gbest_acc": 68.25
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.062416,
+ "gbest_acc": 68.05
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.061096,
+ "gbest_acc": 68.3
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.058372,
+ "gbest_acc": 67.75
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.053314,
+ "gbest_acc": 67.8
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.050725,
+ "gbest_acc": 68.55
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.047276,
+ "gbest_acc": 69.25
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.044209,
+ "gbest_acc": 68.7
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.038957,
+ "gbest_acc": 69.6
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.037232,
+ "gbest_acc": 69.25
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.032942,
+ "gbest_acc": 69.8
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.032444,
+ "gbest_acc": 68.75
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.030327,
+ "gbest_acc": 69.0
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023551,
+ "gbest_acc": 69.4
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.022235,
+ "gbest_acc": 68.85
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.019947,
+ "gbest_acc": 69.75
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.016871,
+ "gbest_acc": 69.55
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.016871,
+ "gbest_acc": 69.55
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.015171,
+ "gbest_acc": 69.55
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.010603,
+ "gbest_acc": 69.5
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.008319,
+ "gbest_acc": 69.2
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.006155,
+ "gbest_acc": 69.45
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.005461,
+ "gbest_acc": 69.4
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.005461,
+ "gbest_acc": 69.4
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.00081,
+ "gbest_acc": 69.05
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.999095,
+ "gbest_acc": 69.3
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996152,
+ "gbest_acc": 69.45
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.992831,
+ "gbest_acc": 69.2
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990099,
+ "gbest_acc": 69.0
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.982362,
+ "gbest_acc": 69.1
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.977621,
+ "gbest_acc": 69.15
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972235,
+ "gbest_acc": 69.65
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.970549,
+ "gbest_acc": 69.65
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.970549,
+ "gbest_acc": 69.65
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.970549,
+ "gbest_acc": 69.65
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967938,
+ "gbest_acc": 69.3
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967938,
+ "gbest_acc": 69.3
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967938,
+ "gbest_acc": 69.3
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.963616,
+ "gbest_acc": 69.85
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.961929,
+ "gbest_acc": 69.4
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.959653,
+ "gbest_acc": 70.15
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.95492,
+ "gbest_acc": 70.3
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.954049,
+ "gbest_acc": 70.65
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.952687,
+ "gbest_acc": 70.85
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.951865,
+ "gbest_acc": 70.7
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.951518,
+ "gbest_acc": 71.3
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.94806,
+ "gbest_acc": 70.9
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.943535,
+ "gbest_acc": 70.75
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.942143,
+ "gbest_acc": 70.55
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.940954,
+ "gbest_acc": 70.75
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.93955,
+ "gbest_acc": 71.05
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.93955,
+ "gbest_acc": 71.05
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.93955,
+ "gbest_acc": 71.05
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.935864,
+ "gbest_acc": 71.15
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.935334,
+ "gbest_acc": 70.7
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.933899,
+ "gbest_acc": 71.25
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.930898,
+ "gbest_acc": 70.9
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.930617,
+ "gbest_acc": 70.5
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.928494,
+ "gbest_acc": 70.75
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.926649,
+ "gbest_acc": 70.95
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.925583,
+ "gbest_acc": 71.1
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.921936,
+ "gbest_acc": 70.85
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.921936,
+ "gbest_acc": 70.85
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.921936,
+ "gbest_acc": 70.85
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.91951,
+ "gbest_acc": 71.4
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.917361,
+ "gbest_acc": 71.0
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.915782,
+ "gbest_acc": 71.4
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.913696,
+ "gbest_acc": 71.55
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.911252,
+ "gbest_acc": 71.6
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.907087,
+ "gbest_acc": 72.05
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.906356,
+ "gbest_acc": 71.85
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.906334,
+ "gbest_acc": 71.95
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.905775,
+ "gbest_acc": 72.0
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.903732,
+ "gbest_acc": 71.95
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.903041,
+ "gbest_acc": 72.4
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.901364,
+ "gbest_acc": 71.9
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.900261,
+ "gbest_acc": 71.75
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.899337,
+ "gbest_acc": 72.05
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.899166,
+ "gbest_acc": 71.55
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.896556,
+ "gbest_acc": 72.15
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.895237,
+ "gbest_acc": 71.7
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.892941,
+ "gbest_acc": 71.85
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.890067,
+ "gbest_acc": 71.8
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.890067,
+ "gbest_acc": 71.8
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.88965,
+ "gbest_acc": 71.5
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.889519,
+ "gbest_acc": 72.1
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.887432,
+ "gbest_acc": 72.3
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.887432,
+ "gbest_acc": 72.3
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.887432,
+ "gbest_acc": 72.3
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.883807,
+ "gbest_acc": 72.65
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.883807,
+ "gbest_acc": 72.65
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.879692,
+ "gbest_acc": 72.55
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.877926,
+ "gbest_acc": 72.95
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.876398,
+ "gbest_acc": 72.85
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.876398,
+ "gbest_acc": 72.85
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875868,
+ "gbest_acc": 73.4
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.874659,
+ "gbest_acc": 73.65
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87357,
+ "gbest_acc": 73.05
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87357,
+ "gbest_acc": 73.05
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87357,
+ "gbest_acc": 73.05
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.872367,
+ "gbest_acc": 73.45
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.868652,
+ "gbest_acc": 73.85
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.868199,
+ "gbest_acc": 73.05
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.865494,
+ "gbest_acc": 73.75
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.862152,
+ "gbest_acc": 73.55
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.859286,
+ "gbest_acc": 73.95
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858014,
+ "gbest_acc": 73.5
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858014,
+ "gbest_acc": 73.5
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.857257,
+ "gbest_acc": 73.1
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.851526,
+ "gbest_acc": 72.95
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849557,
+ "gbest_acc": 72.9
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.846497,
+ "gbest_acc": 73.0
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.845154,
+ "gbest_acc": 72.25
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.83757,
+ "gbest_acc": 73.3
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.835934,
+ "gbest_acc": 73.2
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.832968,
+ "gbest_acc": 73.5
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.824817,
+ "gbest_acc": 74.4
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.820029,
+ "gbest_acc": 74.9
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.819867,
+ "gbest_acc": 74.5
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.813081,
+ "gbest_acc": 75.45
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.813081,
+ "gbest_acc": 75.45
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.813081,
+ "gbest_acc": 75.45
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.812008,
+ "gbest_acc": 75.1
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.811332,
+ "gbest_acc": 75.2
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809286,
+ "gbest_acc": 75.55
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809286,
+ "gbest_acc": 75.55
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.806178,
+ "gbest_acc": 75.7
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.806178,
+ "gbest_acc": 75.7
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.804606,
+ "gbest_acc": 75.6
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.804596,
+ "gbest_acc": 75.95
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.801692,
+ "gbest_acc": 75.6
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.800279,
+ "gbest_acc": 75.9
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.798591,
+ "gbest_acc": 75.65
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.795726,
+ "gbest_acc": 75.95
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.795726,
+ "gbest_acc": 75.95
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.794934,
+ "gbest_acc": 75.55
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.793447,
+ "gbest_acc": 75.85
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.791375,
+ "gbest_acc": 76.65
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.789059,
+ "gbest_acc": 76.4
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.786868,
+ "gbest_acc": 76.35
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.784611,
+ "gbest_acc": 77.35
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78089,
+ "gbest_acc": 77.3
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.780142,
+ "gbest_acc": 77.65
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.779351,
+ "gbest_acc": 77.45
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.778802,
+ "gbest_acc": 77.7
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.776987,
+ "gbest_acc": 77.05
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.775616,
+ "gbest_acc": 77.7
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.775616,
+ "gbest_acc": 77.7
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.774739,
+ "gbest_acc": 77.2
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.771773,
+ "gbest_acc": 77.5
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.770806,
+ "gbest_acc": 77.25
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.767654,
+ "gbest_acc": 77.15
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.76678,
+ "gbest_acc": 77.55
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.764769,
+ "gbest_acc": 77.55
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.7645,
+ "gbest_acc": 77.55
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.763058,
+ "gbest_acc": 77.65
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.761321,
+ "gbest_acc": 77.35
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758508,
+ "gbest_acc": 77.55
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758508,
+ "gbest_acc": 77.55
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758426,
+ "gbest_acc": 76.9
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.757073,
+ "gbest_acc": 77.25
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.756359,
+ "gbest_acc": 77.3
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.754372,
+ "gbest_acc": 77.55
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.753925,
+ "gbest_acc": 77.5
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.752984,
+ "gbest_acc": 77.4
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.752007,
+ "gbest_acc": 77.45
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.748269,
+ "gbest_acc": 77.85
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74602,
+ "gbest_acc": 78.15
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74602,
+ "gbest_acc": 78.15
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.745546,
+ "gbest_acc": 78.05
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.744801,
+ "gbest_acc": 77.75
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.741927,
+ "gbest_acc": 78.0
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.741238,
+ "gbest_acc": 77.95
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.741238,
+ "gbest_acc": 77.95
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.740132,
+ "gbest_acc": 77.65
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.739728,
+ "gbest_acc": 77.85
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.736891,
+ "gbest_acc": 78.0
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.7365,
+ "gbest_acc": 77.9
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.7349,
+ "gbest_acc": 78.8
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.7349,
+ "gbest_acc": 78.8
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.73257,
+ "gbest_acc": 78.6
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.732201,
+ "gbest_acc": 78.95
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727831,
+ "gbest_acc": 79.15
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727831,
+ "gbest_acc": 79.15
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727831,
+ "gbest_acc": 79.15
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727831,
+ "gbest_acc": 79.15
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727831,
+ "gbest_acc": 79.15
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727798,
+ "gbest_acc": 79.35
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727798,
+ "gbest_acc": 79.35
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.726879,
+ "gbest_acc": 79.75
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.726288,
+ "gbest_acc": 79.7
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.72525,
+ "gbest_acc": 79.6
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.724604,
+ "gbest_acc": 79.75
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.723967,
+ "gbest_acc": 79.6
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.722552,
+ "gbest_acc": 79.8
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721214,
+ "gbest_acc": 79.5
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.720766,
+ "gbest_acc": 79.35
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.719261,
+ "gbest_acc": 79.5
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.719199,
+ "gbest_acc": 79.65
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.718213,
+ "gbest_acc": 79.85
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.71625,
+ "gbest_acc": 79.6
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.716246,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.714436,
+ "gbest_acc": 79.25
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.712348,
+ "gbest_acc": 79.85
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.711912,
+ "gbest_acc": 79.7
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.710829,
+ "gbest_acc": 79.85
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.710277,
+ "gbest_acc": 80.0
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.709882,
+ "gbest_acc": 80.55
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.708938,
+ "gbest_acc": 80.25
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.7068,
+ "gbest_acc": 80.8
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706298,
+ "gbest_acc": 80.95
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705296,
+ "gbest_acc": 80.9
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705015,
+ "gbest_acc": 80.3
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.704457,
+ "gbest_acc": 80.45
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703473,
+ "gbest_acc": 80.55
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.702031,
+ "gbest_acc": 80.9
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.701436,
+ "gbest_acc": 80.85
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.69886,
+ "gbest_acc": 80.75
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.698268,
+ "gbest_acc": 80.85
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696512,
+ "gbest_acc": 80.7
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696512,
+ "gbest_acc": 80.7
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696512,
+ "gbest_acc": 80.7
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693961,
+ "gbest_acc": 80.65
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693904,
+ "gbest_acc": 80.5
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.692863,
+ "gbest_acc": 80.35
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.692863,
+ "gbest_acc": 80.35
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.692863,
+ "gbest_acc": 80.35
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.691791,
+ "gbest_acc": 80.75
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.690606,
+ "gbest_acc": 80.4
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.689373,
+ "gbest_acc": 80.5
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.689106,
+ "gbest_acc": 81.0
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688293,
+ "gbest_acc": 80.85
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.687655,
+ "gbest_acc": 80.45
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.686058,
+ "gbest_acc": 80.3
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.685766,
+ "gbest_acc": 80.8
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.685711,
+ "gbest_acc": 80.45
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.68485,
+ "gbest_acc": 81.05
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.683726,
+ "gbest_acc": 81.15
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.681755,
+ "gbest_acc": 80.8
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.679998,
+ "gbest_acc": 81.45
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.679278,
+ "gbest_acc": 81.3
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.679028,
+ "gbest_acc": 81.5
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.67704,
+ "gbest_acc": 81.65
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.675753,
+ "gbest_acc": 81.85
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.674136,
+ "gbest_acc": 81.55
+ },
+ {
+ "epoch": 421,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.724293,
+ "gbest_acc": 78.22
+ },
+ {
+ "epoch": 422,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.723167,
+ "gbest_acc": 78.27
+ },
+ {
+ "epoch": 423,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.7209,
+ "gbest_acc": 78.12
+ },
+ {
+ "epoch": 424,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.720167,
+ "gbest_acc": 78.07
+ },
+ {
+ "epoch": 425,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.720167,
+ "gbest_acc": 78.07
+ },
+ {
+ "epoch": 426,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.719833,
+ "gbest_acc": 78.18
+ },
+ {
+ "epoch": 427,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.719692,
+ "gbest_acc": 78.12
+ },
+ {
+ "epoch": 428,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.717417,
+ "gbest_acc": 78.2
+ },
+ {
+ "epoch": 429,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.717417,
+ "gbest_acc": 78.2
+ },
+ {
+ "epoch": 430,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.717136,
+ "gbest_acc": 78.07
+ },
+ {
+ "epoch": 431,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.716335,
+ "gbest_acc": 78.1
+ },
+ {
+ "epoch": 432,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.716239,
+ "gbest_acc": 78.51
+ },
+ {
+ "epoch": 433,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.715308,
+ "gbest_acc": 78.43
+ },
+ {
+ "epoch": 434,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.714539,
+ "gbest_acc": 78.63
+ },
+ {
+ "epoch": 435,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.713865,
+ "gbest_acc": 78.4
+ },
+ {
+ "epoch": 436,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.712529,
+ "gbest_acc": 78.61
+ },
+ {
+ "epoch": 437,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.7116,
+ "gbest_acc": 78.61
+ },
+ {
+ "epoch": 438,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.710858,
+ "gbest_acc": 78.59
+ },
+ {
+ "epoch": 439,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.709054,
+ "gbest_acc": 78.67
+ },
+ {
+ "epoch": 440,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.708187,
+ "gbest_acc": 78.65
+ },
+ {
+ "epoch": 441,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.70689,
+ "gbest_acc": 78.71
+ },
+ {
+ "epoch": 442,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.705885,
+ "gbest_acc": 78.67
+ },
+ {
+ "epoch": 443,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.705296,
+ "gbest_acc": 78.59
+ },
+ {
+ "epoch": 444,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.704729,
+ "gbest_acc": 78.58
+ },
+ {
+ "epoch": 445,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.704216,
+ "gbest_acc": 78.68
+ },
+ {
+ "epoch": 446,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.703521,
+ "gbest_acc": 78.61
+ },
+ {
+ "epoch": 447,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.702391,
+ "gbest_acc": 78.56
+ },
+ {
+ "epoch": 448,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.700844,
+ "gbest_acc": 78.77
+ },
+ {
+ "epoch": 449,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.699808,
+ "gbest_acc": 78.77
+ },
+ {
+ "epoch": 450,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.698008,
+ "gbest_acc": 79.03
+ },
+ {
+ "epoch": 451,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.696874,
+ "gbest_acc": 79.02
+ },
+ {
+ "epoch": 452,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.695758,
+ "gbest_acc": 79.2
+ },
+ {
+ "epoch": 453,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.694762,
+ "gbest_acc": 79.1
+ },
+ {
+ "epoch": 454,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.694762,
+ "gbest_acc": 79.1
+ },
+ {
+ "epoch": 455,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.693305,
+ "gbest_acc": 79.07
+ },
+ {
+ "epoch": 456,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.693016,
+ "gbest_acc": 79.17
+ },
+ {
+ "epoch": 457,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.69128,
+ "gbest_acc": 79.12
+ },
+ {
+ "epoch": 458,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.690346,
+ "gbest_acc": 79.03
+ },
+ {
+ "epoch": 459,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.689346,
+ "gbest_acc": 79.01
+ },
+ {
+ "epoch": 460,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.687975,
+ "gbest_acc": 79.09
+ },
+ {
+ "epoch": 461,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.687242,
+ "gbest_acc": 79.02
+ },
+ {
+ "epoch": 462,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.686382,
+ "gbest_acc": 79.13
+ },
+ {
+ "epoch": 463,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.685397,
+ "gbest_acc": 79.28
+ },
+ {
+ "epoch": 464,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.683642,
+ "gbest_acc": 79.4
+ },
+ {
+ "epoch": 465,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.681876,
+ "gbest_acc": 79.55
+ },
+ {
+ "epoch": 466,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.680923,
+ "gbest_acc": 79.5
+ },
+ {
+ "epoch": 467,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.679917,
+ "gbest_acc": 79.53
+ },
+ {
+ "epoch": 468,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.677415,
+ "gbest_acc": 79.41
+ },
+ {
+ "epoch": 469,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.676754,
+ "gbest_acc": 79.67
+ },
+ {
+ "epoch": 470,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.675516,
+ "gbest_acc": 79.66
+ },
+ {
+ "epoch": 471,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.674994,
+ "gbest_acc": 79.59
+ },
+ {
+ "epoch": 472,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.674271,
+ "gbest_acc": 79.44
+ },
+ {
+ "epoch": 473,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.673546,
+ "gbest_acc": 79.4
+ },
+ {
+ "epoch": 474,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.6722,
+ "gbest_acc": 79.36
+ },
+ {
+ "epoch": 475,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.671747,
+ "gbest_acc": 79.53
+ },
+ {
+ "epoch": 476,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.671231,
+ "gbest_acc": 79.62
+ },
+ {
+ "epoch": 477,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.670909,
+ "gbest_acc": 79.65
+ },
+ {
+ "epoch": 478,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.669581,
+ "gbest_acc": 79.68
+ },
+ {
+ "epoch": 479,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.668728,
+ "gbest_acc": 79.67
+ },
+ {
+ "epoch": 480,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.66822,
+ "gbest_acc": 79.67
+ },
+ {
+ "epoch": 481,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.667688,
+ "gbest_acc": 79.64
+ },
+ {
+ "epoch": 482,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.667566,
+ "gbest_acc": 79.76
+ },
+ {
+ "epoch": 483,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.666934,
+ "gbest_acc": 79.73
+ },
+ {
+ "epoch": 484,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.666065,
+ "gbest_acc": 79.83
+ },
+ {
+ "epoch": 485,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.665859,
+ "gbest_acc": 79.65
+ },
+ {
+ "epoch": 486,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.664893,
+ "gbest_acc": 79.84
+ },
+ {
+ "epoch": 487,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.664556,
+ "gbest_acc": 79.94
+ },
+ {
+ "epoch": 488,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.663632,
+ "gbest_acc": 79.75
+ },
+ {
+ "epoch": 489,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.66256,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 490,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.662295,
+ "gbest_acc": 79.83
+ },
+ {
+ "epoch": 491,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.66172,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 492,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.661337,
+ "gbest_acc": 79.88
+ },
+ {
+ "epoch": 493,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.661203,
+ "gbest_acc": 80.0
+ },
+ {
+ "epoch": 494,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.660553,
+ "gbest_acc": 79.98
+ },
+ {
+ "epoch": 495,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.660494,
+ "gbest_acc": 79.89
+ },
+ {
+ "epoch": 496,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.660054,
+ "gbest_acc": 79.8
+ },
+ {
+ "epoch": 497,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.659395,
+ "gbest_acc": 79.93
+ },
+ {
+ "epoch": 498,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.658877,
+ "gbest_acc": 79.99
+ },
+ {
+ "epoch": 499,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.658445,
+ "gbest_acc": 79.89
+ },
+ {
+ "epoch": 500,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.658445,
+ "gbest_acc": 79.89
+ },
+ {
+ "epoch": 501,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.658132,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 502,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.657728,
+ "gbest_acc": 79.94
+ },
+ {
+ "epoch": 503,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.657233,
+ "gbest_acc": 80.11
+ },
+ {
+ "epoch": 504,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.656494,
+ "gbest_acc": 80.27
+ },
+ {
+ "epoch": 505,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.656237,
+ "gbest_acc": 80.28
+ },
+ {
+ "epoch": 506,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.655713,
+ "gbest_acc": 80.18
+ },
+ {
+ "epoch": 507,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.654708,
+ "gbest_acc": 80.13
+ },
+ {
+ "epoch": 508,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.654338,
+ "gbest_acc": 80.31
+ },
+ {
+ "epoch": 509,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.653009,
+ "gbest_acc": 80.3
+ },
+ {
+ "epoch": 510,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.652088,
+ "gbest_acc": 80.39
+ },
+ {
+ "epoch": 511,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.651874,
+ "gbest_acc": 80.27
+ },
+ {
+ "epoch": 512,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.650963,
+ "gbest_acc": 80.27
+ },
+ {
+ "epoch": 513,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.650882,
+ "gbest_acc": 80.28
+ },
+ {
+ "epoch": 514,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.649732,
+ "gbest_acc": 80.22
+ },
+ {
+ "epoch": 515,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.648132,
+ "gbest_acc": 80.31
+ },
+ {
+ "epoch": 516,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.647513,
+ "gbest_acc": 80.31
+ },
+ {
+ "epoch": 517,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.646853,
+ "gbest_acc": 80.33
+ },
+ {
+ "epoch": 518,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.646226,
+ "gbest_acc": 80.37
+ },
+ {
+ "epoch": 519,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.646226,
+ "gbest_acc": 80.37
+ },
+ {
+ "epoch": 520,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.646226,
+ "gbest_acc": 80.37
+ },
+ {
+ "epoch": 521,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.645661,
+ "gbest_acc": 80.43
+ },
+ {
+ "epoch": 522,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.644853,
+ "gbest_acc": 80.33
+ },
+ {
+ "epoch": 523,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.644561,
+ "gbest_acc": 80.33
+ },
+ {
+ "epoch": 524,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.644126,
+ "gbest_acc": 80.45
+ },
+ {
+ "epoch": 525,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.64365,
+ "gbest_acc": 80.56
+ },
+ {
+ "epoch": 526,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.643454,
+ "gbest_acc": 80.66
+ },
+ {
+ "epoch": 527,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.643162,
+ "gbest_acc": 80.57
+ },
+ {
+ "epoch": 528,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.642273,
+ "gbest_acc": 80.59
+ },
+ {
+ "epoch": 529,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.641678,
+ "gbest_acc": 80.62
+ },
+ {
+ "epoch": 530,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.640995,
+ "gbest_acc": 80.59
+ },
+ {
+ "epoch": 531,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.640722,
+ "gbest_acc": 80.56
+ },
+ {
+ "epoch": 532,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638861,
+ "gbest_acc": 80.68
+ },
+ {
+ "epoch": 533,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638308,
+ "gbest_acc": 80.6
+ },
+ {
+ "epoch": 534,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638131,
+ "gbest_acc": 80.59
+ },
+ {
+ "epoch": 535,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.637804,
+ "gbest_acc": 80.66
+ },
+ {
+ "epoch": 536,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.635782,
+ "gbest_acc": 80.81
+ },
+ {
+ "epoch": 537,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.634729,
+ "gbest_acc": 80.94
+ },
+ {
+ "epoch": 538,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.63374,
+ "gbest_acc": 81.03
+ },
+ {
+ "epoch": 539,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.632968,
+ "gbest_acc": 80.94
+ },
+ {
+ "epoch": 540,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.632675,
+ "gbest_acc": 81.01
+ },
+ {
+ "epoch": 541,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.632125,
+ "gbest_acc": 80.95
+ },
+ {
+ "epoch": 542,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.631835,
+ "gbest_acc": 81.07
+ },
+ {
+ "epoch": 543,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.630606,
+ "gbest_acc": 81.22
+ },
+ {
+ "epoch": 544,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.630508,
+ "gbest_acc": 81.02
+ },
+ {
+ "epoch": 545,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.629939,
+ "gbest_acc": 81.13
+ },
+ {
+ "epoch": 546,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.629278,
+ "gbest_acc": 81.12
+ },
+ {
+ "epoch": 547,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.628453,
+ "gbest_acc": 81.14
+ },
+ {
+ "epoch": 548,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.62817,
+ "gbest_acc": 81.17
+ },
+ {
+ "epoch": 549,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.627093,
+ "gbest_acc": 81.08
+ },
+ {
+ "epoch": 550,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.626806,
+ "gbest_acc": 81.09
+ },
+ {
+ "epoch": 551,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.625912,
+ "gbest_acc": 81.22
+ },
+ {
+ "epoch": 552,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.625452,
+ "gbest_acc": 81.14
+ },
+ {
+ "epoch": 553,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.624702,
+ "gbest_acc": 81.37
+ },
+ {
+ "epoch": 554,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.624274,
+ "gbest_acc": 81.41
+ },
+ {
+ "epoch": 555,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.623825,
+ "gbest_acc": 81.3
+ },
+ {
+ "epoch": 556,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.634904,
+ "gbest_acc": 80.85
+ },
+ {
+ "epoch": 557,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.63434,
+ "gbest_acc": 80.738
+ },
+ {
+ "epoch": 558,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.634045,
+ "gbest_acc": 80.76
+ },
+ {
+ "epoch": 559,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.634045,
+ "gbest_acc": 80.76
+ },
+ {
+ "epoch": 560,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.633,
+ "gbest_acc": 80.806
+ },
+ {
+ "epoch": 561,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.632233,
+ "gbest_acc": 80.872
+ },
+ {
+ "epoch": 562,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.632233,
+ "gbest_acc": 80.872
+ },
+ {
+ "epoch": 563,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.631618,
+ "gbest_acc": 80.828
+ },
+ {
+ "epoch": 564,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.631089,
+ "gbest_acc": 80.846
+ },
+ {
+ "epoch": 565,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.63059,
+ "gbest_acc": 80.79
+ },
+ {
+ "epoch": 566,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.628975,
+ "gbest_acc": 80.798
+ },
+ {
+ "epoch": 567,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.62822,
+ "gbest_acc": 80.852
+ },
+ {
+ "epoch": 568,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.627056,
+ "gbest_acc": 80.888
+ },
+ {
+ "epoch": 569,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.626238,
+ "gbest_acc": 80.858
+ },
+ {
+ "epoch": 570,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.625282,
+ "gbest_acc": 80.962
+ },
+ {
+ "epoch": 571,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.624616,
+ "gbest_acc": 80.97
+ },
+ {
+ "epoch": 572,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.62452,
+ "gbest_acc": 81.01
+ },
+ {
+ "epoch": 573,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.624423,
+ "gbest_acc": 80.98
+ },
+ {
+ "epoch": 574,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.624154,
+ "gbest_acc": 81.094
+ },
+ {
+ "epoch": 575,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.623264,
+ "gbest_acc": 81.028
+ },
+ {
+ "epoch": 576,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.622745,
+ "gbest_acc": 80.972
+ },
+ {
+ "epoch": 577,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.621654,
+ "gbest_acc": 81.098
+ },
+ {
+ "epoch": 578,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.621369,
+ "gbest_acc": 81.084
+ },
+ {
+ "epoch": 579,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.620671,
+ "gbest_acc": 81.2
+ },
+ {
+ "epoch": 580,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.620397,
+ "gbest_acc": 81.222
+ },
+ {
+ "epoch": 581,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.62037,
+ "gbest_acc": 81.174
+ },
+ {
+ "epoch": 582,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.618919,
+ "gbest_acc": 81.202
+ },
+ {
+ "epoch": 583,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.618087,
+ "gbest_acc": 81.264
+ },
+ {
+ "epoch": 584,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.617881,
+ "gbest_acc": 81.196
+ },
+ {
+ "epoch": 585,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.616748,
+ "gbest_acc": 81.39
+ },
+ {
+ "epoch": 586,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.616451,
+ "gbest_acc": 81.318
+ },
+ {
+ "epoch": 587,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.615757,
+ "gbest_acc": 81.434
+ },
+ {
+ "epoch": 588,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.615424,
+ "gbest_acc": 81.358
+ },
+ {
+ "epoch": 589,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.614451,
+ "gbest_acc": 81.314
+ },
+ {
+ "epoch": 590,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.613749,
+ "gbest_acc": 81.412
+ },
+ {
+ "epoch": 591,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.613383,
+ "gbest_acc": 81.37
+ },
+ {
+ "epoch": 592,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.61299,
+ "gbest_acc": 81.408
+ },
+ {
+ "epoch": 593,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.612144,
+ "gbest_acc": 81.492
+ },
+ {
+ "epoch": 594,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.611775,
+ "gbest_acc": 81.472
+ },
+ {
+ "epoch": 595,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.611346,
+ "gbest_acc": 81.42
+ },
+ {
+ "epoch": 596,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.611133,
+ "gbest_acc": 81.416
+ },
+ {
+ "epoch": 597,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.610471,
+ "gbest_acc": 81.346
+ },
+ {
+ "epoch": 598,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.609686,
+ "gbest_acc": 81.474
+ },
+ {
+ "epoch": 599,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.608916,
+ "gbest_acc": 81.46
+ },
+ {
+ "epoch": 600,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.608214,
+ "gbest_acc": 81.446
+ }
+ ]
+ },
+ {
+ "seed": 102,
+ "val_loss": 0.607417,
+ "val_acc": 82.42,
+ "wall_time_sec": 160.2394,
+ "queries": 36120,
+ "sample_evaluations": 270000000,
+ "transition_reevaluations": 120,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.314652,
+ "gbest_acc": 8.3
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.307074,
+ "gbest_acc": 8.55
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.297392,
+ "gbest_acc": 10.1
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.28717,
+ "gbest_acc": 10.95
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.273744,
+ "gbest_acc": 11.6
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.252855,
+ "gbest_acc": 15.85
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.243629,
+ "gbest_acc": 11.25
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.217047,
+ "gbest_acc": 15.4
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.183382,
+ "gbest_acc": 18.95
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.165299,
+ "gbest_acc": 21.35
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.145566,
+ "gbest_acc": 19.45
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.127849,
+ "gbest_acc": 21.5
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.105398,
+ "gbest_acc": 21.45
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.086457,
+ "gbest_acc": 24.25
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.066531,
+ "gbest_acc": 22.2
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.035558,
+ "gbest_acc": 26.55
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.007202,
+ "gbest_acc": 27.05
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.965906,
+ "gbest_acc": 32.1
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.947275,
+ "gbest_acc": 34.9
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.940691,
+ "gbest_acc": 29.4
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.918899,
+ "gbest_acc": 33.05
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.896375,
+ "gbest_acc": 31.05
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.878475,
+ "gbest_acc": 31.6
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.860492,
+ "gbest_acc": 35.2
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.851936,
+ "gbest_acc": 34.05
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.845591,
+ "gbest_acc": 38.4
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.845591,
+ "gbest_acc": 38.4
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.834479,
+ "gbest_acc": 35.1
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.833447,
+ "gbest_acc": 38.8
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.824804,
+ "gbest_acc": 34.85
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.822194,
+ "gbest_acc": 36.45
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.804917,
+ "gbest_acc": 38.2
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.765187,
+ "gbest_acc": 38.35
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.765187,
+ "gbest_acc": 38.35
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.765187,
+ "gbest_acc": 38.35
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74679,
+ "gbest_acc": 43.9
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.716333,
+ "gbest_acc": 45.8
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.716333,
+ "gbest_acc": 45.8
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.699197,
+ "gbest_acc": 47.55
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.699197,
+ "gbest_acc": 47.55
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.68106,
+ "gbest_acc": 44.7
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.67915,
+ "gbest_acc": 44.4
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.67915,
+ "gbest_acc": 44.4
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.67915,
+ "gbest_acc": 44.4
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.669368,
+ "gbest_acc": 45.85
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.650319,
+ "gbest_acc": 44.2
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624876,
+ "gbest_acc": 46.5
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624876,
+ "gbest_acc": 46.5
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624876,
+ "gbest_acc": 46.5
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624876,
+ "gbest_acc": 46.5
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624876,
+ "gbest_acc": 46.5
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.620737,
+ "gbest_acc": 46.8
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.614751,
+ "gbest_acc": 47.05
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.611005,
+ "gbest_acc": 46.65
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.611005,
+ "gbest_acc": 46.65
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.60279,
+ "gbest_acc": 46.45
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.60279,
+ "gbest_acc": 46.45
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.590976,
+ "gbest_acc": 47.7
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585731,
+ "gbest_acc": 46.65
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.567063,
+ "gbest_acc": 48.45
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566095,
+ "gbest_acc": 47.75
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566095,
+ "gbest_acc": 47.75
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.565008,
+ "gbest_acc": 49.4
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.555486,
+ "gbest_acc": 49.7
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.542135,
+ "gbest_acc": 49.05
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.542135,
+ "gbest_acc": 49.05
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.542135,
+ "gbest_acc": 49.05
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.541545,
+ "gbest_acc": 50.6
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.526902,
+ "gbest_acc": 50.25
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.526902,
+ "gbest_acc": 50.25
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.526902,
+ "gbest_acc": 50.25
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.526902,
+ "gbest_acc": 50.25
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.51951,
+ "gbest_acc": 50.7
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.498642,
+ "gbest_acc": 52.0
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.496327,
+ "gbest_acc": 50.25
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.494415,
+ "gbest_acc": 51.1
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.490218,
+ "gbest_acc": 51.4
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.490218,
+ "gbest_acc": 51.4
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.481633,
+ "gbest_acc": 50.55
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.47603,
+ "gbest_acc": 51.35
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.468274,
+ "gbest_acc": 51.7
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.442822,
+ "gbest_acc": 52.2
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.442822,
+ "gbest_acc": 52.2
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.442822,
+ "gbest_acc": 52.2
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.438751,
+ "gbest_acc": 51.95
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.438751,
+ "gbest_acc": 51.95
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.438751,
+ "gbest_acc": 51.95
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.435832,
+ "gbest_acc": 52.25
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.424029,
+ "gbest_acc": 52.6
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.415219,
+ "gbest_acc": 53.9
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.411691,
+ "gbest_acc": 54.25
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.405668,
+ "gbest_acc": 54.85
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.40175,
+ "gbest_acc": 55.35
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.40175,
+ "gbest_acc": 55.35
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.390965,
+ "gbest_acc": 54.65
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.387506,
+ "gbest_acc": 54.8
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.37445,
+ "gbest_acc": 54.8
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.36889,
+ "gbest_acc": 54.45
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.36889,
+ "gbest_acc": 54.45
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357239,
+ "gbest_acc": 55.8
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.354371,
+ "gbest_acc": 56.35
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.342632,
+ "gbest_acc": 56.55
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.342632,
+ "gbest_acc": 56.55
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338905,
+ "gbest_acc": 56.05
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338597,
+ "gbest_acc": 55.75
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338597,
+ "gbest_acc": 55.75
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338597,
+ "gbest_acc": 55.75
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.337692,
+ "gbest_acc": 56.1
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.324701,
+ "gbest_acc": 56.25
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.315555,
+ "gbest_acc": 56.0
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.301927,
+ "gbest_acc": 57.35
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.30187,
+ "gbest_acc": 55.85
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.294439,
+ "gbest_acc": 56.4
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.288193,
+ "gbest_acc": 57.4
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.286711,
+ "gbest_acc": 58.25
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279207,
+ "gbest_acc": 58.35
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279207,
+ "gbest_acc": 58.35
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279207,
+ "gbest_acc": 58.35
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279158,
+ "gbest_acc": 58.35
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.272414,
+ "gbest_acc": 58.85
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.264844,
+ "gbest_acc": 59.4
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.264431,
+ "gbest_acc": 59.15
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.259469,
+ "gbest_acc": 60.25
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.256783,
+ "gbest_acc": 59.35
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.244226,
+ "gbest_acc": 59.4
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.244226,
+ "gbest_acc": 59.4
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.241135,
+ "gbest_acc": 60.9
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.241135,
+ "gbest_acc": 60.9
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.241135,
+ "gbest_acc": 60.9
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240735,
+ "gbest_acc": 60.0
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.233855,
+ "gbest_acc": 60.15
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.229202,
+ "gbest_acc": 60.45
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.21979,
+ "gbest_acc": 61.6
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.217945,
+ "gbest_acc": 61.85
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.215931,
+ "gbest_acc": 62.2
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.212862,
+ "gbest_acc": 61.7
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.206706,
+ "gbest_acc": 62.1
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.200585,
+ "gbest_acc": 62.4
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.198178,
+ "gbest_acc": 61.75
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.198178,
+ "gbest_acc": 61.75
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.197236,
+ "gbest_acc": 61.95
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.189314,
+ "gbest_acc": 62.6
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.188823,
+ "gbest_acc": 63.0
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.188823,
+ "gbest_acc": 63.0
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.1849,
+ "gbest_acc": 61.85
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.180699,
+ "gbest_acc": 62.35
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.180699,
+ "gbest_acc": 62.35
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.173609,
+ "gbest_acc": 63.4
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172583,
+ "gbest_acc": 63.2
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172583,
+ "gbest_acc": 63.2
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172583,
+ "gbest_acc": 63.2
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.166791,
+ "gbest_acc": 62.7
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.15976,
+ "gbest_acc": 62.9
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.15976,
+ "gbest_acc": 62.9
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.15976,
+ "gbest_acc": 62.9
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.159218,
+ "gbest_acc": 62.35
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146688,
+ "gbest_acc": 64.15
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.138206,
+ "gbest_acc": 64.2
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.138206,
+ "gbest_acc": 64.2
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.134563,
+ "gbest_acc": 63.65
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.134531,
+ "gbest_acc": 64.3
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.131781,
+ "gbest_acc": 64.7
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.131781,
+ "gbest_acc": 64.7
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.124419,
+ "gbest_acc": 65.55
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.124419,
+ "gbest_acc": 65.55
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12252,
+ "gbest_acc": 65.4
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.113842,
+ "gbest_acc": 66.35
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.110181,
+ "gbest_acc": 65.2
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.092788,
+ "gbest_acc": 66.5
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.092788,
+ "gbest_acc": 66.5
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.086808,
+ "gbest_acc": 67.55
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.086808,
+ "gbest_acc": 67.55
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.086808,
+ "gbest_acc": 67.55
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.083006,
+ "gbest_acc": 68.25
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.083006,
+ "gbest_acc": 68.25
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.078634,
+ "gbest_acc": 67.6
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.076644,
+ "gbest_acc": 68.7
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.069482,
+ "gbest_acc": 68.3
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.069482,
+ "gbest_acc": 68.3
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.069482,
+ "gbest_acc": 68.3
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.067201,
+ "gbest_acc": 67.75
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.061537,
+ "gbest_acc": 68.9
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.058474,
+ "gbest_acc": 68.0
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.052531,
+ "gbest_acc": 69.1
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.052531,
+ "gbest_acc": 69.1
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.04625,
+ "gbest_acc": 69.1
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.04625,
+ "gbest_acc": 69.1
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.042485,
+ "gbest_acc": 68.95
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.041149,
+ "gbest_acc": 68.75
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.039684,
+ "gbest_acc": 68.8
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.033789,
+ "gbest_acc": 68.65
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.033789,
+ "gbest_acc": 68.65
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.033789,
+ "gbest_acc": 68.65
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.033789,
+ "gbest_acc": 68.65
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.030624,
+ "gbest_acc": 68.65
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.027454,
+ "gbest_acc": 69.45
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.026228,
+ "gbest_acc": 69.5
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.026228,
+ "gbest_acc": 69.5
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.026185,
+ "gbest_acc": 69.25
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.02296,
+ "gbest_acc": 68.95
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.02296,
+ "gbest_acc": 68.95
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.020996,
+ "gbest_acc": 69.6
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.020827,
+ "gbest_acc": 69.8
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.016117,
+ "gbest_acc": 69.55
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.016117,
+ "gbest_acc": 69.55
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.01034,
+ "gbest_acc": 69.95
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.004329,
+ "gbest_acc": 70.0
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.999995,
+ "gbest_acc": 70.35
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.998319,
+ "gbest_acc": 70.2
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.997328,
+ "gbest_acc": 70.3
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.997328,
+ "gbest_acc": 70.3
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.995448,
+ "gbest_acc": 70.05
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993219,
+ "gbest_acc": 70.2
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993219,
+ "gbest_acc": 70.2
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.992821,
+ "gbest_acc": 69.65
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990639,
+ "gbest_acc": 70.0
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990639,
+ "gbest_acc": 70.0
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.986865,
+ "gbest_acc": 69.95
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.986462,
+ "gbest_acc": 70.2
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.985291,
+ "gbest_acc": 70.95
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.981928,
+ "gbest_acc": 71.1
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.979631,
+ "gbest_acc": 71.05
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.977874,
+ "gbest_acc": 70.95
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.977874,
+ "gbest_acc": 70.95
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.977527,
+ "gbest_acc": 71.1
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.97486,
+ "gbest_acc": 71.2
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974409,
+ "gbest_acc": 71.05
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972908,
+ "gbest_acc": 70.8
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.971808,
+ "gbest_acc": 71.2
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.969579,
+ "gbest_acc": 71.25
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.968587,
+ "gbest_acc": 71.35
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.96688,
+ "gbest_acc": 71.3
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.965884,
+ "gbest_acc": 71.05
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.96359,
+ "gbest_acc": 71.55
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.960981,
+ "gbest_acc": 71.75
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.959857,
+ "gbest_acc": 71.4
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.956078,
+ "gbest_acc": 71.5
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.95393,
+ "gbest_acc": 71.7
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.952867,
+ "gbest_acc": 71.55
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.951699,
+ "gbest_acc": 72.05
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.950461,
+ "gbest_acc": 71.8
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.948031,
+ "gbest_acc": 71.6
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.946963,
+ "gbest_acc": 71.8
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.946191,
+ "gbest_acc": 71.45
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.943494,
+ "gbest_acc": 71.0
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.939644,
+ "gbest_acc": 72.0
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.938408,
+ "gbest_acc": 72.2
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.933589,
+ "gbest_acc": 71.8
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.931715,
+ "gbest_acc": 72.45
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.929173,
+ "gbest_acc": 72.9
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.928511,
+ "gbest_acc": 72.75
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.924153,
+ "gbest_acc": 73.75
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.922962,
+ "gbest_acc": 73.85
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.921783,
+ "gbest_acc": 73.1
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.919202,
+ "gbest_acc": 73.35
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.915467,
+ "gbest_acc": 73.25
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.912743,
+ "gbest_acc": 73.05
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.908684,
+ "gbest_acc": 73.1
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.905977,
+ "gbest_acc": 73.1
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.904212,
+ "gbest_acc": 73.45
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.903407,
+ "gbest_acc": 73.2
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.902569,
+ "gbest_acc": 73.45
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.902569,
+ "gbest_acc": 73.45
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.902569,
+ "gbest_acc": 73.45
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.898396,
+ "gbest_acc": 73.7
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.895054,
+ "gbest_acc": 73.85
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.895054,
+ "gbest_acc": 73.85
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.895054,
+ "gbest_acc": 73.85
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.893603,
+ "gbest_acc": 74.35
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.890936,
+ "gbest_acc": 73.55
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.889924,
+ "gbest_acc": 74.6
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.886818,
+ "gbest_acc": 73.85
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.886256,
+ "gbest_acc": 73.95
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.883929,
+ "gbest_acc": 74.95
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882713,
+ "gbest_acc": 74.45
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.879608,
+ "gbest_acc": 75.0
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87869,
+ "gbest_acc": 73.6
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.877565,
+ "gbest_acc": 74.2
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.877565,
+ "gbest_acc": 74.2
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.874346,
+ "gbest_acc": 73.9
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87296,
+ "gbest_acc": 74.25
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87296,
+ "gbest_acc": 74.25
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.870583,
+ "gbest_acc": 74.0
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.869763,
+ "gbest_acc": 74.3
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.864861,
+ "gbest_acc": 74.65
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.862648,
+ "gbest_acc": 75.6
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.862648,
+ "gbest_acc": 75.6
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.862648,
+ "gbest_acc": 75.6
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.860939,
+ "gbest_acc": 75.25
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.857851,
+ "gbest_acc": 74.55
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.856109,
+ "gbest_acc": 74.45
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.856109,
+ "gbest_acc": 74.45
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.856109,
+ "gbest_acc": 74.45
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.853822,
+ "gbest_acc": 74.35
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849314,
+ "gbest_acc": 74.65
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849314,
+ "gbest_acc": 74.65
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.848943,
+ "gbest_acc": 75.0
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.848943,
+ "gbest_acc": 75.0
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.84763,
+ "gbest_acc": 74.8
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.845862,
+ "gbest_acc": 74.8
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.844209,
+ "gbest_acc": 74.9
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.842649,
+ "gbest_acc": 75.2
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.842035,
+ "gbest_acc": 75.15
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.842035,
+ "gbest_acc": 75.15
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840957,
+ "gbest_acc": 75.45
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840782,
+ "gbest_acc": 75.35
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.836568,
+ "gbest_acc": 75.55
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.835198,
+ "gbest_acc": 75.8
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.831646,
+ "gbest_acc": 75.8
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.830903,
+ "gbest_acc": 75.7
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.830903,
+ "gbest_acc": 75.7
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.829431,
+ "gbest_acc": 75.9
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.827964,
+ "gbest_acc": 75.8
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.825519,
+ "gbest_acc": 75.35
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.822015,
+ "gbest_acc": 75.4
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.819995,
+ "gbest_acc": 75.2
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.817396,
+ "gbest_acc": 75.1
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.814144,
+ "gbest_acc": 75.75
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.813451,
+ "gbest_acc": 75.55
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.812722,
+ "gbest_acc": 75.9
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809965,
+ "gbest_acc": 75.65
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809808,
+ "gbest_acc": 75.4
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809808,
+ "gbest_acc": 75.4
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809097,
+ "gbest_acc": 76.05
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.806982,
+ "gbest_acc": 75.95
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.806982,
+ "gbest_acc": 75.95
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.805955,
+ "gbest_acc": 75.2
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.802151,
+ "gbest_acc": 76.15
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.801166,
+ "gbest_acc": 75.6
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.800552,
+ "gbest_acc": 75.6
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.799835,
+ "gbest_acc": 75.8
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.797643,
+ "gbest_acc": 75.4
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.795492,
+ "gbest_acc": 75.9
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.793841,
+ "gbest_acc": 76.1
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.793469,
+ "gbest_acc": 75.95
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.792353,
+ "gbest_acc": 75.85
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78711,
+ "gbest_acc": 76.55
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78711,
+ "gbest_acc": 76.55
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78711,
+ "gbest_acc": 76.55
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78711,
+ "gbest_acc": 76.55
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78533,
+ "gbest_acc": 76.75
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78319,
+ "gbest_acc": 76.7
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.781373,
+ "gbest_acc": 76.85
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.780377,
+ "gbest_acc": 76.75
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.779606,
+ "gbest_acc": 77.35
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.777132,
+ "gbest_acc": 77.3
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.775368,
+ "gbest_acc": 77.1
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.774383,
+ "gbest_acc": 77.25
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.772905,
+ "gbest_acc": 77.25
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.77197,
+ "gbest_acc": 77.3
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.771525,
+ "gbest_acc": 77.25
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.771186,
+ "gbest_acc": 77.65
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.769141,
+ "gbest_acc": 77.55
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.767085,
+ "gbest_acc": 77.45
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.76446,
+ "gbest_acc": 77.7
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.762553,
+ "gbest_acc": 78.0
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.762553,
+ "gbest_acc": 78.0
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.760135,
+ "gbest_acc": 77.85
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758586,
+ "gbest_acc": 77.8
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758024,
+ "gbest_acc": 77.95
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.756876,
+ "gbest_acc": 77.8
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.756084,
+ "gbest_acc": 78.15
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.753892,
+ "gbest_acc": 77.65
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.747448,
+ "gbest_acc": 78.1
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.747448,
+ "gbest_acc": 78.1
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.745438,
+ "gbest_acc": 78.1
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.744494,
+ "gbest_acc": 78.45
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743097,
+ "gbest_acc": 78.15
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743031,
+ "gbest_acc": 78.45
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.739867,
+ "gbest_acc": 78.5
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.739239,
+ "gbest_acc": 78.45
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.737655,
+ "gbest_acc": 78.0
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.736735,
+ "gbest_acc": 78.65
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.736735,
+ "gbest_acc": 78.65
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735868,
+ "gbest_acc": 78.55
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735493,
+ "gbest_acc": 78.5
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735493,
+ "gbest_acc": 78.5
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.73454,
+ "gbest_acc": 78.2
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.730302,
+ "gbest_acc": 78.5
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.729784,
+ "gbest_acc": 78.65
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.729661,
+ "gbest_acc": 78.75
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727899,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.726996,
+ "gbest_acc": 78.95
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.723473,
+ "gbest_acc": 78.15
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.722752,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.722752,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.720699,
+ "gbest_acc": 78.7
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.71868,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.715937,
+ "gbest_acc": 78.95
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.715652,
+ "gbest_acc": 79.15
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.713642,
+ "gbest_acc": 79.3
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.711798,
+ "gbest_acc": 79.3
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.711798,
+ "gbest_acc": 79.3
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.710805,
+ "gbest_acc": 79.25
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.70921,
+ "gbest_acc": 79.7
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.708995,
+ "gbest_acc": 79.35
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706735,
+ "gbest_acc": 79.8
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706185,
+ "gbest_acc": 79.65
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706185,
+ "gbest_acc": 79.65
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706185,
+ "gbest_acc": 79.65
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705462,
+ "gbest_acc": 79.5
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703696,
+ "gbest_acc": 79.55
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703042,
+ "gbest_acc": 79.2
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.702466,
+ "gbest_acc": 79.8
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.701364,
+ "gbest_acc": 79.75
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.699386,
+ "gbest_acc": 79.3
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.698578,
+ "gbest_acc": 79.6
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.698021,
+ "gbest_acc": 79.45
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696922,
+ "gbest_acc": 79.55
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696208,
+ "gbest_acc": 79.45
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696148,
+ "gbest_acc": 79.0
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.695361,
+ "gbest_acc": 79.5
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.694744,
+ "gbest_acc": 79.85
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.694622,
+ "gbest_acc": 79.7
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693111,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.692406,
+ "gbest_acc": 79.7
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.689232,
+ "gbest_acc": 79.5
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.689232,
+ "gbest_acc": 79.5
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.689232,
+ "gbest_acc": 79.5
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.689232,
+ "gbest_acc": 79.5
+ },
+ {
+ "epoch": 421,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.724572,
+ "gbest_acc": 78.81
+ },
+ {
+ "epoch": 422,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.724126,
+ "gbest_acc": 78.96
+ },
+ {
+ "epoch": 423,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.7205,
+ "gbest_acc": 79.18
+ },
+ {
+ "epoch": 424,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.720406,
+ "gbest_acc": 79.25
+ },
+ {
+ "epoch": 425,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.720353,
+ "gbest_acc": 79.17
+ },
+ {
+ "epoch": 426,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.719274,
+ "gbest_acc": 79.29
+ },
+ {
+ "epoch": 427,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.71806,
+ "gbest_acc": 79.08
+ },
+ {
+ "epoch": 428,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.717053,
+ "gbest_acc": 79.09
+ },
+ {
+ "epoch": 429,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.715146,
+ "gbest_acc": 78.96
+ },
+ {
+ "epoch": 430,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.712637,
+ "gbest_acc": 79.16
+ },
+ {
+ "epoch": 431,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.712194,
+ "gbest_acc": 79.29
+ },
+ {
+ "epoch": 432,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.712194,
+ "gbest_acc": 79.29
+ },
+ {
+ "epoch": 433,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.712194,
+ "gbest_acc": 79.29
+ },
+ {
+ "epoch": 434,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.711067,
+ "gbest_acc": 79.29
+ },
+ {
+ "epoch": 435,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.710198,
+ "gbest_acc": 79.36
+ },
+ {
+ "epoch": 436,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.708902,
+ "gbest_acc": 79.31
+ },
+ {
+ "epoch": 437,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.708902,
+ "gbest_acc": 79.31
+ },
+ {
+ "epoch": 438,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.707728,
+ "gbest_acc": 79.59
+ },
+ {
+ "epoch": 439,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.706462,
+ "gbest_acc": 79.44
+ },
+ {
+ "epoch": 440,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.705037,
+ "gbest_acc": 79.58
+ },
+ {
+ "epoch": 441,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.704508,
+ "gbest_acc": 79.49
+ },
+ {
+ "epoch": 442,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.703758,
+ "gbest_acc": 79.63
+ },
+ {
+ "epoch": 443,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.702816,
+ "gbest_acc": 79.54
+ },
+ {
+ "epoch": 444,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.702125,
+ "gbest_acc": 79.49
+ },
+ {
+ "epoch": 445,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.700849,
+ "gbest_acc": 79.34
+ },
+ {
+ "epoch": 446,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.699874,
+ "gbest_acc": 79.56
+ },
+ {
+ "epoch": 447,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.697846,
+ "gbest_acc": 79.59
+ },
+ {
+ "epoch": 448,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.697835,
+ "gbest_acc": 79.72
+ },
+ {
+ "epoch": 449,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.696189,
+ "gbest_acc": 79.65
+ },
+ {
+ "epoch": 450,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.696189,
+ "gbest_acc": 79.65
+ },
+ {
+ "epoch": 451,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.695671,
+ "gbest_acc": 79.65
+ },
+ {
+ "epoch": 452,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.694817,
+ "gbest_acc": 79.58
+ },
+ {
+ "epoch": 453,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.693786,
+ "gbest_acc": 79.65
+ },
+ {
+ "epoch": 454,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.691991,
+ "gbest_acc": 79.79
+ },
+ {
+ "epoch": 455,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.691991,
+ "gbest_acc": 79.79
+ },
+ {
+ "epoch": 456,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.69153,
+ "gbest_acc": 79.64
+ },
+ {
+ "epoch": 457,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.690145,
+ "gbest_acc": 79.91
+ },
+ {
+ "epoch": 458,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.688983,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 459,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.688372,
+ "gbest_acc": 80.0
+ },
+ {
+ "epoch": 460,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.687258,
+ "gbest_acc": 80.01
+ },
+ {
+ "epoch": 461,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.686287,
+ "gbest_acc": 80.21
+ },
+ {
+ "epoch": 462,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.686041,
+ "gbest_acc": 80.07
+ },
+ {
+ "epoch": 463,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.682805,
+ "gbest_acc": 80.24
+ },
+ {
+ "epoch": 464,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.682805,
+ "gbest_acc": 80.24
+ },
+ {
+ "epoch": 465,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.681404,
+ "gbest_acc": 80.16
+ },
+ {
+ "epoch": 466,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.68101,
+ "gbest_acc": 80.34
+ },
+ {
+ "epoch": 467,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.680744,
+ "gbest_acc": 80.31
+ },
+ {
+ "epoch": 468,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.678939,
+ "gbest_acc": 80.27
+ },
+ {
+ "epoch": 469,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.677958,
+ "gbest_acc": 80.34
+ },
+ {
+ "epoch": 470,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.676866,
+ "gbest_acc": 80.26
+ },
+ {
+ "epoch": 471,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.675389,
+ "gbest_acc": 80.21
+ },
+ {
+ "epoch": 472,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.675389,
+ "gbest_acc": 80.21
+ },
+ {
+ "epoch": 473,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.673885,
+ "gbest_acc": 80.28
+ },
+ {
+ "epoch": 474,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.673885,
+ "gbest_acc": 80.28
+ },
+ {
+ "epoch": 475,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.673139,
+ "gbest_acc": 80.35
+ },
+ {
+ "epoch": 476,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.669463,
+ "gbest_acc": 80.39
+ },
+ {
+ "epoch": 477,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.669463,
+ "gbest_acc": 80.39
+ },
+ {
+ "epoch": 478,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.669463,
+ "gbest_acc": 80.39
+ },
+ {
+ "epoch": 479,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.669457,
+ "gbest_acc": 80.41
+ },
+ {
+ "epoch": 480,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.668841,
+ "gbest_acc": 80.56
+ },
+ {
+ "epoch": 481,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.668759,
+ "gbest_acc": 80.41
+ },
+ {
+ "epoch": 482,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.668759,
+ "gbest_acc": 80.41
+ },
+ {
+ "epoch": 483,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.668365,
+ "gbest_acc": 80.32
+ },
+ {
+ "epoch": 484,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.667482,
+ "gbest_acc": 80.42
+ },
+ {
+ "epoch": 485,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.666564,
+ "gbest_acc": 80.78
+ },
+ {
+ "epoch": 486,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.666564,
+ "gbest_acc": 80.78
+ },
+ {
+ "epoch": 487,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.666349,
+ "gbest_acc": 80.79
+ },
+ {
+ "epoch": 488,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.666237,
+ "gbest_acc": 80.77
+ },
+ {
+ "epoch": 489,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.665083,
+ "gbest_acc": 80.66
+ },
+ {
+ "epoch": 490,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.663951,
+ "gbest_acc": 80.69
+ },
+ {
+ "epoch": 491,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.663281,
+ "gbest_acc": 80.69
+ },
+ {
+ "epoch": 492,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.662345,
+ "gbest_acc": 80.75
+ },
+ {
+ "epoch": 493,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.661375,
+ "gbest_acc": 80.85
+ },
+ {
+ "epoch": 494,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.660128,
+ "gbest_acc": 80.84
+ },
+ {
+ "epoch": 495,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.660128,
+ "gbest_acc": 80.84
+ },
+ {
+ "epoch": 496,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.659526,
+ "gbest_acc": 80.66
+ },
+ {
+ "epoch": 497,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.658919,
+ "gbest_acc": 80.65
+ },
+ {
+ "epoch": 498,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.658919,
+ "gbest_acc": 80.65
+ },
+ {
+ "epoch": 499,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.658146,
+ "gbest_acc": 80.67
+ },
+ {
+ "epoch": 500,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.656206,
+ "gbest_acc": 80.55
+ },
+ {
+ "epoch": 501,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.655882,
+ "gbest_acc": 80.69
+ },
+ {
+ "epoch": 502,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.654981,
+ "gbest_acc": 80.82
+ },
+ {
+ "epoch": 503,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.653577,
+ "gbest_acc": 80.77
+ },
+ {
+ "epoch": 504,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.653383,
+ "gbest_acc": 80.77
+ },
+ {
+ "epoch": 505,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.653383,
+ "gbest_acc": 80.77
+ },
+ {
+ "epoch": 506,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.653383,
+ "gbest_acc": 80.77
+ },
+ {
+ "epoch": 507,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.65326,
+ "gbest_acc": 80.8
+ },
+ {
+ "epoch": 508,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.653027,
+ "gbest_acc": 80.86
+ },
+ {
+ "epoch": 509,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.652431,
+ "gbest_acc": 81.1
+ },
+ {
+ "epoch": 510,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.650992,
+ "gbest_acc": 81.09
+ },
+ {
+ "epoch": 511,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.649152,
+ "gbest_acc": 81.24
+ },
+ {
+ "epoch": 512,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.649152,
+ "gbest_acc": 81.24
+ },
+ {
+ "epoch": 513,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.648219,
+ "gbest_acc": 81.52
+ },
+ {
+ "epoch": 514,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.647136,
+ "gbest_acc": 81.51
+ },
+ {
+ "epoch": 515,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.646599,
+ "gbest_acc": 81.17
+ },
+ {
+ "epoch": 516,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.646599,
+ "gbest_acc": 81.17
+ },
+ {
+ "epoch": 517,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.6461,
+ "gbest_acc": 81.24
+ },
+ {
+ "epoch": 518,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.6461,
+ "gbest_acc": 81.24
+ },
+ {
+ "epoch": 519,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.64548,
+ "gbest_acc": 81.19
+ },
+ {
+ "epoch": 520,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.645433,
+ "gbest_acc": 81.57
+ },
+ {
+ "epoch": 521,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.645433,
+ "gbest_acc": 81.57
+ },
+ {
+ "epoch": 522,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.645433,
+ "gbest_acc": 81.57
+ },
+ {
+ "epoch": 523,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.644086,
+ "gbest_acc": 81.26
+ },
+ {
+ "epoch": 524,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.64324,
+ "gbest_acc": 81.05
+ },
+ {
+ "epoch": 525,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.64324,
+ "gbest_acc": 81.05
+ },
+ {
+ "epoch": 526,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.64324,
+ "gbest_acc": 81.05
+ },
+ {
+ "epoch": 527,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.64324,
+ "gbest_acc": 81.05
+ },
+ {
+ "epoch": 528,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.643087,
+ "gbest_acc": 81.17
+ },
+ {
+ "epoch": 529,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.642789,
+ "gbest_acc": 81.21
+ },
+ {
+ "epoch": 530,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.642725,
+ "gbest_acc": 81.2
+ },
+ {
+ "epoch": 531,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.640803,
+ "gbest_acc": 81.13
+ },
+ {
+ "epoch": 532,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.640803,
+ "gbest_acc": 81.13
+ },
+ {
+ "epoch": 533,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.640383,
+ "gbest_acc": 81.42
+ },
+ {
+ "epoch": 534,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.639557,
+ "gbest_acc": 81.53
+ },
+ {
+ "epoch": 535,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638432,
+ "gbest_acc": 81.49
+ },
+ {
+ "epoch": 536,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.6383,
+ "gbest_acc": 81.53
+ },
+ {
+ "epoch": 537,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.636265,
+ "gbest_acc": 81.53
+ },
+ {
+ "epoch": 538,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.636265,
+ "gbest_acc": 81.53
+ },
+ {
+ "epoch": 539,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.636265,
+ "gbest_acc": 81.53
+ },
+ {
+ "epoch": 540,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.6362,
+ "gbest_acc": 81.54
+ },
+ {
+ "epoch": 541,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.635736,
+ "gbest_acc": 81.59
+ },
+ {
+ "epoch": 542,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.635002,
+ "gbest_acc": 81.63
+ },
+ {
+ "epoch": 543,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.634799,
+ "gbest_acc": 81.73
+ },
+ {
+ "epoch": 544,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.634608,
+ "gbest_acc": 81.85
+ },
+ {
+ "epoch": 545,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.634043,
+ "gbest_acc": 81.55
+ },
+ {
+ "epoch": 546,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.633982,
+ "gbest_acc": 81.68
+ },
+ {
+ "epoch": 547,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.632937,
+ "gbest_acc": 81.55
+ },
+ {
+ "epoch": 548,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.632455,
+ "gbest_acc": 81.41
+ },
+ {
+ "epoch": 549,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.631454,
+ "gbest_acc": 81.52
+ },
+ {
+ "epoch": 550,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.631454,
+ "gbest_acc": 81.52
+ },
+ {
+ "epoch": 551,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.631082,
+ "gbest_acc": 81.56
+ },
+ {
+ "epoch": 552,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.630811,
+ "gbest_acc": 81.6
+ },
+ {
+ "epoch": 553,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.630811,
+ "gbest_acc": 81.6
+ },
+ {
+ "epoch": 554,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.630811,
+ "gbest_acc": 81.6
+ },
+ {
+ "epoch": 555,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.630418,
+ "gbest_acc": 81.52
+ },
+ {
+ "epoch": 556,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.634825,
+ "gbest_acc": 81.182
+ },
+ {
+ "epoch": 557,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.634327,
+ "gbest_acc": 81.164
+ },
+ {
+ "epoch": 558,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.632866,
+ "gbest_acc": 81.308
+ },
+ {
+ "epoch": 559,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.632858,
+ "gbest_acc": 81.306
+ },
+ {
+ "epoch": 560,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.632858,
+ "gbest_acc": 81.306
+ },
+ {
+ "epoch": 561,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.631709,
+ "gbest_acc": 81.358
+ },
+ {
+ "epoch": 562,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.631515,
+ "gbest_acc": 81.24
+ },
+ {
+ "epoch": 563,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.630863,
+ "gbest_acc": 81.27
+ },
+ {
+ "epoch": 564,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.630863,
+ "gbest_acc": 81.27
+ },
+ {
+ "epoch": 565,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.629907,
+ "gbest_acc": 81.312
+ },
+ {
+ "epoch": 566,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.629907,
+ "gbest_acc": 81.312
+ },
+ {
+ "epoch": 567,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.629907,
+ "gbest_acc": 81.312
+ },
+ {
+ "epoch": 568,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.629415,
+ "gbest_acc": 81.332
+ },
+ {
+ "epoch": 569,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.628621,
+ "gbest_acc": 81.38
+ },
+ {
+ "epoch": 570,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.627784,
+ "gbest_acc": 81.464
+ },
+ {
+ "epoch": 571,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.626699,
+ "gbest_acc": 81.562
+ },
+ {
+ "epoch": 572,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.626526,
+ "gbest_acc": 81.506
+ },
+ {
+ "epoch": 573,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.624878,
+ "gbest_acc": 81.54
+ },
+ {
+ "epoch": 574,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.624878,
+ "gbest_acc": 81.54
+ },
+ {
+ "epoch": 575,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.624867,
+ "gbest_acc": 81.462
+ },
+ {
+ "epoch": 576,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.624624,
+ "gbest_acc": 81.454
+ },
+ {
+ "epoch": 577,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.624624,
+ "gbest_acc": 81.454
+ },
+ {
+ "epoch": 578,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.623607,
+ "gbest_acc": 81.458
+ },
+ {
+ "epoch": 579,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.622896,
+ "gbest_acc": 81.566
+ },
+ {
+ "epoch": 580,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.621943,
+ "gbest_acc": 81.57
+ },
+ {
+ "epoch": 581,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.621943,
+ "gbest_acc": 81.57
+ },
+ {
+ "epoch": 582,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.621943,
+ "gbest_acc": 81.57
+ },
+ {
+ "epoch": 583,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.621737,
+ "gbest_acc": 81.622
+ },
+ {
+ "epoch": 584,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.621737,
+ "gbest_acc": 81.622
+ },
+ {
+ "epoch": 585,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.621395,
+ "gbest_acc": 81.672
+ },
+ {
+ "epoch": 586,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.621345,
+ "gbest_acc": 81.638
+ },
+ {
+ "epoch": 587,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.620167,
+ "gbest_acc": 81.57
+ },
+ {
+ "epoch": 588,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.620167,
+ "gbest_acc": 81.57
+ },
+ {
+ "epoch": 589,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.619871,
+ "gbest_acc": 81.554
+ },
+ {
+ "epoch": 590,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.619527,
+ "gbest_acc": 81.55
+ },
+ {
+ "epoch": 591,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.619187,
+ "gbest_acc": 81.548
+ },
+ {
+ "epoch": 592,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.61884,
+ "gbest_acc": 81.686
+ },
+ {
+ "epoch": 593,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.61815,
+ "gbest_acc": 81.638
+ },
+ {
+ "epoch": 594,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.61785,
+ "gbest_acc": 81.64
+ },
+ {
+ "epoch": 595,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.617004,
+ "gbest_acc": 81.718
+ },
+ {
+ "epoch": 596,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.617004,
+ "gbest_acc": 81.718
+ },
+ {
+ "epoch": 597,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.616977,
+ "gbest_acc": 81.742
+ },
+ {
+ "epoch": 598,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.615994,
+ "gbest_acc": 81.816
+ },
+ {
+ "epoch": 599,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.614795,
+ "gbest_acc": 81.778
+ },
+ {
+ "epoch": 600,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.614199,
+ "gbest_acc": 81.79
+ }
+ ]
+ },
+ {
+ "seed": 103,
+ "val_loss": 0.571431,
+ "val_acc": 82.64,
+ "wall_time_sec": 163.8031,
+ "queries": 36120,
+ "sample_evaluations": 270000000,
+ "transition_reevaluations": 120,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.306736,
+ "gbest_acc": 7.75
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.301095,
+ "gbest_acc": 9.25
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.285218,
+ "gbest_acc": 10.85
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.272207,
+ "gbest_acc": 13.9
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.258712,
+ "gbest_acc": 11.9
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.237577,
+ "gbest_acc": 11.35
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.219055,
+ "gbest_acc": 17.45
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.190786,
+ "gbest_acc": 19.15
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.165014,
+ "gbest_acc": 20.8
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.1444,
+ "gbest_acc": 21.4
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.133009,
+ "gbest_acc": 25.85
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.124876,
+ "gbest_acc": 25.6
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.123546,
+ "gbest_acc": 29.0
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.120491,
+ "gbest_acc": 26.15
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.092338,
+ "gbest_acc": 27.6
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.070742,
+ "gbest_acc": 28.2
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.055494,
+ "gbest_acc": 29.1
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.050444,
+ "gbest_acc": 28.95
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.03032,
+ "gbest_acc": 29.25
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.019969,
+ "gbest_acc": 25.95
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.98332,
+ "gbest_acc": 31.6
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.981001,
+ "gbest_acc": 33.5
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.953625,
+ "gbest_acc": 36.95
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.92213,
+ "gbest_acc": 37.4
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.92213,
+ "gbest_acc": 37.4
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.899446,
+ "gbest_acc": 36.3
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.881171,
+ "gbest_acc": 37.0
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.872066,
+ "gbest_acc": 38.4
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.872066,
+ "gbest_acc": 38.4
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.865758,
+ "gbest_acc": 37.15
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.864147,
+ "gbest_acc": 34.2
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.850855,
+ "gbest_acc": 35.35
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.843205,
+ "gbest_acc": 37.1
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.832204,
+ "gbest_acc": 40.35
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.812147,
+ "gbest_acc": 41.6
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.79039,
+ "gbest_acc": 43.75
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.769716,
+ "gbest_acc": 40.9
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.736351,
+ "gbest_acc": 45.75
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.736351,
+ "gbest_acc": 45.75
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.736351,
+ "gbest_acc": 45.75
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.728965,
+ "gbest_acc": 43.65
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.713552,
+ "gbest_acc": 42.9
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.710279,
+ "gbest_acc": 44.95
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.695853,
+ "gbest_acc": 44.6
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.684053,
+ "gbest_acc": 44.9
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.669037,
+ "gbest_acc": 45.0
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.648473,
+ "gbest_acc": 45.7
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.635661,
+ "gbest_acc": 45.9
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624055,
+ "gbest_acc": 46.95
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624055,
+ "gbest_acc": 46.95
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.61576,
+ "gbest_acc": 48.0
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.608881,
+ "gbest_acc": 49.15
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.593466,
+ "gbest_acc": 49.6
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.59304,
+ "gbest_acc": 48.65
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.59304,
+ "gbest_acc": 48.65
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.591888,
+ "gbest_acc": 49.0
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.588175,
+ "gbest_acc": 48.15
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.579923,
+ "gbest_acc": 48.75
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.564046,
+ "gbest_acc": 50.1
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.538632,
+ "gbest_acc": 52.2
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5157,
+ "gbest_acc": 51.95
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5157,
+ "gbest_acc": 51.95
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.50663,
+ "gbest_acc": 52.95
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.50663,
+ "gbest_acc": 52.95
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.50663,
+ "gbest_acc": 52.95
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.503698,
+ "gbest_acc": 53.65
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.489288,
+ "gbest_acc": 54.4
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.485936,
+ "gbest_acc": 53.85
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460079,
+ "gbest_acc": 54.45
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460079,
+ "gbest_acc": 54.45
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452602,
+ "gbest_acc": 54.35
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.447585,
+ "gbest_acc": 54.75
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.441106,
+ "gbest_acc": 55.8
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.439717,
+ "gbest_acc": 56.05
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.437439,
+ "gbest_acc": 56.45
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.433568,
+ "gbest_acc": 56.05
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.40237,
+ "gbest_acc": 55.9
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.40237,
+ "gbest_acc": 55.9
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.391686,
+ "gbest_acc": 56.0
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388501,
+ "gbest_acc": 56.8
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388501,
+ "gbest_acc": 56.8
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.376475,
+ "gbest_acc": 57.7
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.376475,
+ "gbest_acc": 57.7
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.372706,
+ "gbest_acc": 59.3
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.370302,
+ "gbest_acc": 56.4
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.365972,
+ "gbest_acc": 58.0
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362269,
+ "gbest_acc": 57.9
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362269,
+ "gbest_acc": 57.9
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.346876,
+ "gbest_acc": 59.35
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.34618,
+ "gbest_acc": 59.5
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.34618,
+ "gbest_acc": 59.5
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.340091,
+ "gbest_acc": 59.35
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.339939,
+ "gbest_acc": 60.2
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.337373,
+ "gbest_acc": 59.25
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331855,
+ "gbest_acc": 59.2
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.324059,
+ "gbest_acc": 59.45
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.31277,
+ "gbest_acc": 59.9
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.31277,
+ "gbest_acc": 59.9
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.31277,
+ "gbest_acc": 59.9
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.31277,
+ "gbest_acc": 59.9
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.311186,
+ "gbest_acc": 59.9
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.295752,
+ "gbest_acc": 60.2
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.29065,
+ "gbest_acc": 61.7
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.286527,
+ "gbest_acc": 61.55
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.277146,
+ "gbest_acc": 61.6
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.277109,
+ "gbest_acc": 62.3
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.271287,
+ "gbest_acc": 63.0
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.266966,
+ "gbest_acc": 63.1
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.264454,
+ "gbest_acc": 62.9
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.250973,
+ "gbest_acc": 63.0
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.250973,
+ "gbest_acc": 63.0
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.249803,
+ "gbest_acc": 63.95
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240184,
+ "gbest_acc": 63.1
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240184,
+ "gbest_acc": 63.1
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.231357,
+ "gbest_acc": 64.6
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.225667,
+ "gbest_acc": 63.65
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.225667,
+ "gbest_acc": 63.65
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.225667,
+ "gbest_acc": 63.65
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.222204,
+ "gbest_acc": 62.0
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.209307,
+ "gbest_acc": 62.8
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.209307,
+ "gbest_acc": 62.8
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.209307,
+ "gbest_acc": 62.8
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.209307,
+ "gbest_acc": 62.8
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.207785,
+ "gbest_acc": 63.55
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.197787,
+ "gbest_acc": 63.25
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.189766,
+ "gbest_acc": 63.9
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.185945,
+ "gbest_acc": 64.2
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.18107,
+ "gbest_acc": 64.5
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177859,
+ "gbest_acc": 65.25
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177859,
+ "gbest_acc": 65.25
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.175997,
+ "gbest_acc": 65.0
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.175997,
+ "gbest_acc": 65.0
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.167975,
+ "gbest_acc": 65.35
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.167975,
+ "gbest_acc": 65.35
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.165835,
+ "gbest_acc": 65.0
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.154847,
+ "gbest_acc": 64.8
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.154847,
+ "gbest_acc": 64.8
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.154847,
+ "gbest_acc": 64.8
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.152015,
+ "gbest_acc": 65.55
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.142405,
+ "gbest_acc": 66.4
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136753,
+ "gbest_acc": 66.1
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.131296,
+ "gbest_acc": 67.3
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.128003,
+ "gbest_acc": 66.75
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.127023,
+ "gbest_acc": 68.2
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.116981,
+ "gbest_acc": 67.2
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.113859,
+ "gbest_acc": 67.75
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.112615,
+ "gbest_acc": 67.45
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.112615,
+ "gbest_acc": 67.45
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.112615,
+ "gbest_acc": 67.45
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.108195,
+ "gbest_acc": 68.15
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.105821,
+ "gbest_acc": 68.45
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.098881,
+ "gbest_acc": 68.0
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.098881,
+ "gbest_acc": 68.0
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.097065,
+ "gbest_acc": 68.7
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.091826,
+ "gbest_acc": 67.3
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.091826,
+ "gbest_acc": 67.3
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.091826,
+ "gbest_acc": 67.3
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.091826,
+ "gbest_acc": 67.3
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.085993,
+ "gbest_acc": 67.1
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.0805,
+ "gbest_acc": 67.95
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.0805,
+ "gbest_acc": 67.95
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.0805,
+ "gbest_acc": 67.95
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.079882,
+ "gbest_acc": 68.2
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.072072,
+ "gbest_acc": 68.95
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.068064,
+ "gbest_acc": 68.25
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.068064,
+ "gbest_acc": 68.25
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.068064,
+ "gbest_acc": 68.25
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.067065,
+ "gbest_acc": 66.95
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.065015,
+ "gbest_acc": 68.35
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.059447,
+ "gbest_acc": 69.25
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.054845,
+ "gbest_acc": 68.6
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.054161,
+ "gbest_acc": 68.85
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.049072,
+ "gbest_acc": 68.95
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.046123,
+ "gbest_acc": 68.8
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.041408,
+ "gbest_acc": 69.5
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.040558,
+ "gbest_acc": 68.95
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.031737,
+ "gbest_acc": 70.25
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.028511,
+ "gbest_acc": 69.85
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023249,
+ "gbest_acc": 69.05
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.016179,
+ "gbest_acc": 69.8
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.012743,
+ "gbest_acc": 69.75
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.01063,
+ "gbest_acc": 69.8
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.0028,
+ "gbest_acc": 70.55
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.998192,
+ "gbest_acc": 70.3
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996972,
+ "gbest_acc": 70.6
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996323,
+ "gbest_acc": 70.9
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996054,
+ "gbest_acc": 71.1
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990807,
+ "gbest_acc": 70.95
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990807,
+ "gbest_acc": 70.95
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990807,
+ "gbest_acc": 70.95
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990807,
+ "gbest_acc": 70.95
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.985284,
+ "gbest_acc": 71.5
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.982009,
+ "gbest_acc": 71.35
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.976879,
+ "gbest_acc": 71.75
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974518,
+ "gbest_acc": 71.95
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.970424,
+ "gbest_acc": 70.95
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.96579,
+ "gbest_acc": 71.6
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.963927,
+ "gbest_acc": 70.8
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.952596,
+ "gbest_acc": 72.05
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.952596,
+ "gbest_acc": 72.05
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.949662,
+ "gbest_acc": 71.3
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.949662,
+ "gbest_acc": 71.3
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.949662,
+ "gbest_acc": 71.3
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.949662,
+ "gbest_acc": 71.3
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.948342,
+ "gbest_acc": 71.8
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.947457,
+ "gbest_acc": 72.35
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.947457,
+ "gbest_acc": 72.35
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.945712,
+ "gbest_acc": 72.15
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.943871,
+ "gbest_acc": 72.15
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.942873,
+ "gbest_acc": 72.15
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.942561,
+ "gbest_acc": 72.75
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.939768,
+ "gbest_acc": 72.9
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.938839,
+ "gbest_acc": 72.4
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.938839,
+ "gbest_acc": 72.4
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.936866,
+ "gbest_acc": 71.7
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.934088,
+ "gbest_acc": 72.55
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.930037,
+ "gbest_acc": 72.9
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.927044,
+ "gbest_acc": 72.9
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92671,
+ "gbest_acc": 73.0
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92671,
+ "gbest_acc": 73.0
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.926611,
+ "gbest_acc": 73.25
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.926314,
+ "gbest_acc": 72.85
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.9212,
+ "gbest_acc": 73.65
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.9212,
+ "gbest_acc": 73.65
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.920458,
+ "gbest_acc": 73.7
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.91804,
+ "gbest_acc": 73.25
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.917395,
+ "gbest_acc": 73.05
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.915533,
+ "gbest_acc": 73.05
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.911938,
+ "gbest_acc": 72.9
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.910837,
+ "gbest_acc": 73.85
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.906496,
+ "gbest_acc": 73.4
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.906496,
+ "gbest_acc": 73.4
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.904315,
+ "gbest_acc": 73.5
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.901337,
+ "gbest_acc": 73.55
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.896518,
+ "gbest_acc": 73.1
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.893546,
+ "gbest_acc": 73.4
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.893017,
+ "gbest_acc": 73.5
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.887085,
+ "gbest_acc": 73.4
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.88624,
+ "gbest_acc": 73.6
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.88405,
+ "gbest_acc": 73.7
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.883748,
+ "gbest_acc": 73.0
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.881804,
+ "gbest_acc": 72.9
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.879689,
+ "gbest_acc": 72.55
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875991,
+ "gbest_acc": 73.65
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87316,
+ "gbest_acc": 73.7
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87316,
+ "gbest_acc": 73.7
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87316,
+ "gbest_acc": 73.7
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87316,
+ "gbest_acc": 73.7
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.867962,
+ "gbest_acc": 73.8
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.866012,
+ "gbest_acc": 74.3
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.866012,
+ "gbest_acc": 74.3
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.864239,
+ "gbest_acc": 74.25
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.860096,
+ "gbest_acc": 74.4
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.856701,
+ "gbest_acc": 74.1
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.853515,
+ "gbest_acc": 74.4
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.852115,
+ "gbest_acc": 74.7
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.852115,
+ "gbest_acc": 74.7
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.851773,
+ "gbest_acc": 75.25
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.844992,
+ "gbest_acc": 75.0
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.842961,
+ "gbest_acc": 75.2
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.836906,
+ "gbest_acc": 74.95
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.83479,
+ "gbest_acc": 75.1
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.831892,
+ "gbest_acc": 75.05
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.827771,
+ "gbest_acc": 75.55
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.82755,
+ "gbest_acc": 75.5
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821007,
+ "gbest_acc": 75.95
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821007,
+ "gbest_acc": 75.95
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.820722,
+ "gbest_acc": 75.3
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.817764,
+ "gbest_acc": 75.25
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.816037,
+ "gbest_acc": 75.4
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.816037,
+ "gbest_acc": 75.4
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.816019,
+ "gbest_acc": 75.55
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.815747,
+ "gbest_acc": 75.4
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.811207,
+ "gbest_acc": 75.05
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.810918,
+ "gbest_acc": 75.35
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.806153,
+ "gbest_acc": 76.0
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.805389,
+ "gbest_acc": 75.7
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.803133,
+ "gbest_acc": 75.6
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.80152,
+ "gbest_acc": 76.05
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.799068,
+ "gbest_acc": 75.35
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.795189,
+ "gbest_acc": 76.05
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.791493,
+ "gbest_acc": 75.5
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78925,
+ "gbest_acc": 75.75
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.787026,
+ "gbest_acc": 76.1
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.785627,
+ "gbest_acc": 76.4
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.783846,
+ "gbest_acc": 76.15
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.783099,
+ "gbest_acc": 76.35
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.780425,
+ "gbest_acc": 76.5
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.780425,
+ "gbest_acc": 76.5
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.780425,
+ "gbest_acc": 76.5
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.778617,
+ "gbest_acc": 76.6
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.778617,
+ "gbest_acc": 76.6
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.778617,
+ "gbest_acc": 76.6
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.777562,
+ "gbest_acc": 76.85
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.776054,
+ "gbest_acc": 76.6
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.774242,
+ "gbest_acc": 76.0
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.771723,
+ "gbest_acc": 76.7
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.770772,
+ "gbest_acc": 76.25
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.770772,
+ "gbest_acc": 76.25
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.767923,
+ "gbest_acc": 76.5
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.765344,
+ "gbest_acc": 76.75
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.760478,
+ "gbest_acc": 76.9
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.759708,
+ "gbest_acc": 76.7
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.759708,
+ "gbest_acc": 76.7
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.759708,
+ "gbest_acc": 76.7
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758703,
+ "gbest_acc": 76.95
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.757969,
+ "gbest_acc": 77.15
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.756851,
+ "gbest_acc": 77.1
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.755139,
+ "gbest_acc": 77.0
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.754044,
+ "gbest_acc": 77.6
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.753835,
+ "gbest_acc": 77.5
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.752081,
+ "gbest_acc": 77.5
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.751282,
+ "gbest_acc": 77.4
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.751124,
+ "gbest_acc": 77.9
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.751124,
+ "gbest_acc": 77.9
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.750689,
+ "gbest_acc": 77.2
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.750036,
+ "gbest_acc": 77.35
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.748378,
+ "gbest_acc": 77.6
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.748378,
+ "gbest_acc": 77.6
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.748288,
+ "gbest_acc": 77.5
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.747121,
+ "gbest_acc": 77.75
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.747121,
+ "gbest_acc": 77.75
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.746989,
+ "gbest_acc": 77.5
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.745148,
+ "gbest_acc": 77.65
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.745148,
+ "gbest_acc": 77.65
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.745148,
+ "gbest_acc": 77.65
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.745148,
+ "gbest_acc": 77.65
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.744493,
+ "gbest_acc": 77.4
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743618,
+ "gbest_acc": 77.55
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743618,
+ "gbest_acc": 77.55
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743618,
+ "gbest_acc": 77.55
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.742591,
+ "gbest_acc": 77.5
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.742294,
+ "gbest_acc": 77.45
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.739846,
+ "gbest_acc": 77.85
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.738035,
+ "gbest_acc": 78.0
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.738035,
+ "gbest_acc": 78.0
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.737536,
+ "gbest_acc": 78.15
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.734811,
+ "gbest_acc": 78.1
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.734472,
+ "gbest_acc": 78.15
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.734472,
+ "gbest_acc": 78.15
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.732684,
+ "gbest_acc": 78.6
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.731943,
+ "gbest_acc": 78.65
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.73034,
+ "gbest_acc": 78.7
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.729459,
+ "gbest_acc": 78.2
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.728827,
+ "gbest_acc": 78.8
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.728827,
+ "gbest_acc": 78.8
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727253,
+ "gbest_acc": 78.25
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.726281,
+ "gbest_acc": 78.55
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.726218,
+ "gbest_acc": 78.5
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725197,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.723366,
+ "gbest_acc": 78.5
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.723366,
+ "gbest_acc": 78.5
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.72195,
+ "gbest_acc": 78.95
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721935,
+ "gbest_acc": 78.8
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.720438,
+ "gbest_acc": 78.95
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.720438,
+ "gbest_acc": 78.95
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.719655,
+ "gbest_acc": 79.0
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.71599,
+ "gbest_acc": 78.9
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.715115,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.713009,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.713009,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.712787,
+ "gbest_acc": 78.55
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.711991,
+ "gbest_acc": 78.45
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.710542,
+ "gbest_acc": 78.7
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.707947,
+ "gbest_acc": 78.65
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.707947,
+ "gbest_acc": 78.65
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.707947,
+ "gbest_acc": 78.65
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.707723,
+ "gbest_acc": 78.9
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706873,
+ "gbest_acc": 78.95
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706873,
+ "gbest_acc": 78.95
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705886,
+ "gbest_acc": 79.5
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.704177,
+ "gbest_acc": 79.25
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703561,
+ "gbest_acc": 79.2
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.700903,
+ "gbest_acc": 79.1
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.700325,
+ "gbest_acc": 79.1
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.698249,
+ "gbest_acc": 79.1
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.697164,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696311,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.695122,
+ "gbest_acc": 79.2
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.694546,
+ "gbest_acc": 78.95
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693627,
+ "gbest_acc": 79.15
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693097,
+ "gbest_acc": 79.5
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.69208,
+ "gbest_acc": 78.95
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.690316,
+ "gbest_acc": 79.0
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.689485,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.689485,
+ "gbest_acc": 78.85
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688707,
+ "gbest_acc": 79.05
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.68777,
+ "gbest_acc": 79.2
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.687206,
+ "gbest_acc": 79.2
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.685674,
+ "gbest_acc": 79.1
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.684901,
+ "gbest_acc": 79.25
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.683547,
+ "gbest_acc": 78.75
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.683547,
+ "gbest_acc": 78.75
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.681737,
+ "gbest_acc": 78.95
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.679609,
+ "gbest_acc": 79.6
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.678753,
+ "gbest_acc": 79.45
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.677508,
+ "gbest_acc": 79.75
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.676859,
+ "gbest_acc": 79.75
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.675131,
+ "gbest_acc": 79.75
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.673131,
+ "gbest_acc": 80.25
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.672688,
+ "gbest_acc": 79.95
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.669044,
+ "gbest_acc": 80.0
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.666953,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.666953,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.666807,
+ "gbest_acc": 80.0
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.666701,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.666701,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.666302,
+ "gbest_acc": 80.0
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.665223,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.664132,
+ "gbest_acc": 80.0
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.663237,
+ "gbest_acc": 80.1
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.661927,
+ "gbest_acc": 80.05
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.661845,
+ "gbest_acc": 80.15
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.661006,
+ "gbest_acc": 79.95
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.660849,
+ "gbest_acc": 80.2
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.65935,
+ "gbest_acc": 79.95
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.658599,
+ "gbest_acc": 80.3
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.658599,
+ "gbest_acc": 80.3
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.658597,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.658095,
+ "gbest_acc": 80.3
+ },
+ {
+ "epoch": 421,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.688882,
+ "gbest_acc": 79.42
+ },
+ {
+ "epoch": 422,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.686865,
+ "gbest_acc": 79.55
+ },
+ {
+ "epoch": 423,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.686865,
+ "gbest_acc": 79.55
+ },
+ {
+ "epoch": 424,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.685854,
+ "gbest_acc": 79.58
+ },
+ {
+ "epoch": 425,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.684352,
+ "gbest_acc": 79.49
+ },
+ {
+ "epoch": 426,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.683997,
+ "gbest_acc": 79.3
+ },
+ {
+ "epoch": 427,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.683997,
+ "gbest_acc": 79.3
+ },
+ {
+ "epoch": 428,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.683886,
+ "gbest_acc": 79.28
+ },
+ {
+ "epoch": 429,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.68223,
+ "gbest_acc": 79.4
+ },
+ {
+ "epoch": 430,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.680538,
+ "gbest_acc": 79.37
+ },
+ {
+ "epoch": 431,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.679737,
+ "gbest_acc": 79.42
+ },
+ {
+ "epoch": 432,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.679737,
+ "gbest_acc": 79.42
+ },
+ {
+ "epoch": 433,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.678634,
+ "gbest_acc": 79.48
+ },
+ {
+ "epoch": 434,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.67778,
+ "gbest_acc": 79.62
+ },
+ {
+ "epoch": 435,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.676583,
+ "gbest_acc": 79.65
+ },
+ {
+ "epoch": 436,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.674747,
+ "gbest_acc": 79.8
+ },
+ {
+ "epoch": 437,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.674736,
+ "gbest_acc": 79.86
+ },
+ {
+ "epoch": 438,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.672816,
+ "gbest_acc": 80.0
+ },
+ {
+ "epoch": 439,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.67159,
+ "gbest_acc": 80.01
+ },
+ {
+ "epoch": 440,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.669726,
+ "gbest_acc": 80.04
+ },
+ {
+ "epoch": 441,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.669061,
+ "gbest_acc": 80.05
+ },
+ {
+ "epoch": 442,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.668568,
+ "gbest_acc": 80.13
+ },
+ {
+ "epoch": 443,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.667834,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 444,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.667834,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 445,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.667834,
+ "gbest_acc": 79.9
+ },
+ {
+ "epoch": 446,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.667194,
+ "gbest_acc": 79.98
+ },
+ {
+ "epoch": 447,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.666022,
+ "gbest_acc": 79.89
+ },
+ {
+ "epoch": 448,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.665353,
+ "gbest_acc": 79.99
+ },
+ {
+ "epoch": 449,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.663327,
+ "gbest_acc": 80.15
+ },
+ {
+ "epoch": 450,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.661987,
+ "gbest_acc": 79.81
+ },
+ {
+ "epoch": 451,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.660576,
+ "gbest_acc": 80.26
+ },
+ {
+ "epoch": 452,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.659783,
+ "gbest_acc": 80.12
+ },
+ {
+ "epoch": 453,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.657148,
+ "gbest_acc": 80.19
+ },
+ {
+ "epoch": 454,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.656825,
+ "gbest_acc": 80.15
+ },
+ {
+ "epoch": 455,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.655766,
+ "gbest_acc": 80.34
+ },
+ {
+ "epoch": 456,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.654152,
+ "gbest_acc": 80.46
+ },
+ {
+ "epoch": 457,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.653869,
+ "gbest_acc": 80.37
+ },
+ {
+ "epoch": 458,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.65223,
+ "gbest_acc": 80.51
+ },
+ {
+ "epoch": 459,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.650463,
+ "gbest_acc": 80.49
+ },
+ {
+ "epoch": 460,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.650247,
+ "gbest_acc": 80.65
+ },
+ {
+ "epoch": 461,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.648186,
+ "gbest_acc": 80.81
+ },
+ {
+ "epoch": 462,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.648186,
+ "gbest_acc": 80.81
+ },
+ {
+ "epoch": 463,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.647492,
+ "gbest_acc": 80.79
+ },
+ {
+ "epoch": 464,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.646377,
+ "gbest_acc": 80.82
+ },
+ {
+ "epoch": 465,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.644114,
+ "gbest_acc": 81.08
+ },
+ {
+ "epoch": 466,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.64401,
+ "gbest_acc": 80.75
+ },
+ {
+ "epoch": 467,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.643605,
+ "gbest_acc": 80.65
+ },
+ {
+ "epoch": 468,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.643165,
+ "gbest_acc": 80.55
+ },
+ {
+ "epoch": 469,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.643165,
+ "gbest_acc": 80.55
+ },
+ {
+ "epoch": 470,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.642747,
+ "gbest_acc": 80.69
+ },
+ {
+ "epoch": 471,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.641703,
+ "gbest_acc": 80.72
+ },
+ {
+ "epoch": 472,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.641703,
+ "gbest_acc": 80.72
+ },
+ {
+ "epoch": 473,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.641308,
+ "gbest_acc": 81.04
+ },
+ {
+ "epoch": 474,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.640995,
+ "gbest_acc": 81.13
+ },
+ {
+ "epoch": 475,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638925,
+ "gbest_acc": 81.03
+ },
+ {
+ "epoch": 476,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638728,
+ "gbest_acc": 81.11
+ },
+ {
+ "epoch": 477,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638713,
+ "gbest_acc": 80.82
+ },
+ {
+ "epoch": 478,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638713,
+ "gbest_acc": 80.82
+ },
+ {
+ "epoch": 479,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638713,
+ "gbest_acc": 80.82
+ },
+ {
+ "epoch": 480,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638358,
+ "gbest_acc": 80.93
+ },
+ {
+ "epoch": 481,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638231,
+ "gbest_acc": 81.21
+ },
+ {
+ "epoch": 482,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.638231,
+ "gbest_acc": 81.21
+ },
+ {
+ "epoch": 483,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.637876,
+ "gbest_acc": 80.93
+ },
+ {
+ "epoch": 484,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.63702,
+ "gbest_acc": 80.96
+ },
+ {
+ "epoch": 485,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.635716,
+ "gbest_acc": 80.88
+ },
+ {
+ "epoch": 486,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.635442,
+ "gbest_acc": 81.25
+ },
+ {
+ "epoch": 487,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.635442,
+ "gbest_acc": 81.25
+ },
+ {
+ "epoch": 488,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.635442,
+ "gbest_acc": 81.25
+ },
+ {
+ "epoch": 489,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.635442,
+ "gbest_acc": 81.25
+ },
+ {
+ "epoch": 490,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.634209,
+ "gbest_acc": 80.95
+ },
+ {
+ "epoch": 491,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.634209,
+ "gbest_acc": 80.95
+ },
+ {
+ "epoch": 492,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.634209,
+ "gbest_acc": 80.95
+ },
+ {
+ "epoch": 493,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.63337,
+ "gbest_acc": 81.13
+ },
+ {
+ "epoch": 494,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.633164,
+ "gbest_acc": 81.11
+ },
+ {
+ "epoch": 495,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.632841,
+ "gbest_acc": 81.22
+ },
+ {
+ "epoch": 496,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.632841,
+ "gbest_acc": 81.22
+ },
+ {
+ "epoch": 497,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.632841,
+ "gbest_acc": 81.22
+ },
+ {
+ "epoch": 498,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.632841,
+ "gbest_acc": 81.22
+ },
+ {
+ "epoch": 499,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.631345,
+ "gbest_acc": 81.18
+ },
+ {
+ "epoch": 500,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.629109,
+ "gbest_acc": 81.54
+ },
+ {
+ "epoch": 501,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.629109,
+ "gbest_acc": 81.54
+ },
+ {
+ "epoch": 502,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.629109,
+ "gbest_acc": 81.54
+ },
+ {
+ "epoch": 503,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.628603,
+ "gbest_acc": 81.57
+ },
+ {
+ "epoch": 504,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.628428,
+ "gbest_acc": 81.34
+ },
+ {
+ "epoch": 505,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.627425,
+ "gbest_acc": 81.27
+ },
+ {
+ "epoch": 506,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.626755,
+ "gbest_acc": 81.23
+ },
+ {
+ "epoch": 507,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.625747,
+ "gbest_acc": 81.26
+ },
+ {
+ "epoch": 508,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.6238,
+ "gbest_acc": 81.61
+ },
+ {
+ "epoch": 509,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.622853,
+ "gbest_acc": 81.85
+ },
+ {
+ "epoch": 510,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.622853,
+ "gbest_acc": 81.85
+ },
+ {
+ "epoch": 511,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.622853,
+ "gbest_acc": 81.85
+ },
+ {
+ "epoch": 512,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.622853,
+ "gbest_acc": 81.85
+ },
+ {
+ "epoch": 513,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.622263,
+ "gbest_acc": 81.55
+ },
+ {
+ "epoch": 514,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.621528,
+ "gbest_acc": 81.72
+ },
+ {
+ "epoch": 515,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.620708,
+ "gbest_acc": 81.68
+ },
+ {
+ "epoch": 516,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.62031,
+ "gbest_acc": 81.56
+ },
+ {
+ "epoch": 517,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.62024,
+ "gbest_acc": 81.44
+ },
+ {
+ "epoch": 518,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.62024,
+ "gbest_acc": 81.44
+ },
+ {
+ "epoch": 519,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.619496,
+ "gbest_acc": 81.33
+ },
+ {
+ "epoch": 520,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.618307,
+ "gbest_acc": 81.46
+ },
+ {
+ "epoch": 521,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.6161,
+ "gbest_acc": 81.36
+ },
+ {
+ "epoch": 522,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.6161,
+ "gbest_acc": 81.36
+ },
+ {
+ "epoch": 523,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.6161,
+ "gbest_acc": 81.36
+ },
+ {
+ "epoch": 524,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.615899,
+ "gbest_acc": 81.33
+ },
+ {
+ "epoch": 525,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.615557,
+ "gbest_acc": 81.43
+ },
+ {
+ "epoch": 526,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.614941,
+ "gbest_acc": 81.61
+ },
+ {
+ "epoch": 527,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.614322,
+ "gbest_acc": 81.47
+ },
+ {
+ "epoch": 528,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.613863,
+ "gbest_acc": 81.58
+ },
+ {
+ "epoch": 529,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.613233,
+ "gbest_acc": 81.77
+ },
+ {
+ "epoch": 530,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.612714,
+ "gbest_acc": 81.69
+ },
+ {
+ "epoch": 531,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.610741,
+ "gbest_acc": 81.73
+ },
+ {
+ "epoch": 532,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.609011,
+ "gbest_acc": 81.56
+ },
+ {
+ "epoch": 533,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.607288,
+ "gbest_acc": 81.78
+ },
+ {
+ "epoch": 534,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.605658,
+ "gbest_acc": 81.84
+ },
+ {
+ "epoch": 535,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.603773,
+ "gbest_acc": 81.92
+ },
+ {
+ "epoch": 536,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.60151,
+ "gbest_acc": 82.05
+ },
+ {
+ "epoch": 537,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.601336,
+ "gbest_acc": 81.91
+ },
+ {
+ "epoch": 538,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.59911,
+ "gbest_acc": 81.84
+ },
+ {
+ "epoch": 539,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.59852,
+ "gbest_acc": 81.81
+ },
+ {
+ "epoch": 540,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.59659,
+ "gbest_acc": 81.84
+ },
+ {
+ "epoch": 541,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.595489,
+ "gbest_acc": 81.86
+ },
+ {
+ "epoch": 542,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.595015,
+ "gbest_acc": 81.64
+ },
+ {
+ "epoch": 543,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.593902,
+ "gbest_acc": 81.77
+ },
+ {
+ "epoch": 544,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.59346,
+ "gbest_acc": 81.85
+ },
+ {
+ "epoch": 545,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.59346,
+ "gbest_acc": 81.85
+ },
+ {
+ "epoch": 546,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.592709,
+ "gbest_acc": 81.96
+ },
+ {
+ "epoch": 547,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.59227,
+ "gbest_acc": 82.17
+ },
+ {
+ "epoch": 548,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.591597,
+ "gbest_acc": 82.17
+ },
+ {
+ "epoch": 549,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.590734,
+ "gbest_acc": 82.25
+ },
+ {
+ "epoch": 550,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.590686,
+ "gbest_acc": 82.13
+ },
+ {
+ "epoch": 551,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.589663,
+ "gbest_acc": 82.19
+ },
+ {
+ "epoch": 552,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.58897,
+ "gbest_acc": 82.37
+ },
+ {
+ "epoch": 553,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.587872,
+ "gbest_acc": 82.32
+ },
+ {
+ "epoch": 554,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.587045,
+ "gbest_acc": 82.35
+ },
+ {
+ "epoch": 555,
+ "stage": 1,
+ "subset_size": 10000,
+ "gbest_loss": 0.586263,
+ "gbest_acc": 82.39
+ },
+ {
+ "epoch": 556,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.600082,
+ "gbest_acc": 81.696
+ },
+ {
+ "epoch": 557,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.599901,
+ "gbest_acc": 81.66
+ },
+ {
+ "epoch": 558,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.599125,
+ "gbest_acc": 81.574
+ },
+ {
+ "epoch": 559,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.598048,
+ "gbest_acc": 81.684
+ },
+ {
+ "epoch": 560,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.597844,
+ "gbest_acc": 81.692
+ },
+ {
+ "epoch": 561,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.597108,
+ "gbest_acc": 81.71
+ },
+ {
+ "epoch": 562,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.596047,
+ "gbest_acc": 81.782
+ },
+ {
+ "epoch": 563,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.594677,
+ "gbest_acc": 81.748
+ },
+ {
+ "epoch": 564,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.593403,
+ "gbest_acc": 81.918
+ },
+ {
+ "epoch": 565,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.592385,
+ "gbest_acc": 81.924
+ },
+ {
+ "epoch": 566,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.592244,
+ "gbest_acc": 81.904
+ },
+ {
+ "epoch": 567,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.591158,
+ "gbest_acc": 81.93
+ },
+ {
+ "epoch": 568,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.591158,
+ "gbest_acc": 81.93
+ },
+ {
+ "epoch": 569,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.590937,
+ "gbest_acc": 82.102
+ },
+ {
+ "epoch": 570,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.590463,
+ "gbest_acc": 82.056
+ },
+ {
+ "epoch": 571,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.59002,
+ "gbest_acc": 82.062
+ },
+ {
+ "epoch": 572,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.588592,
+ "gbest_acc": 82.1
+ },
+ {
+ "epoch": 573,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.588267,
+ "gbest_acc": 82.112
+ },
+ {
+ "epoch": 574,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.587445,
+ "gbest_acc": 82.054
+ },
+ {
+ "epoch": 575,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.587108,
+ "gbest_acc": 82.05
+ },
+ {
+ "epoch": 576,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.58561,
+ "gbest_acc": 82.14
+ },
+ {
+ "epoch": 577,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.58527,
+ "gbest_acc": 82.082
+ },
+ {
+ "epoch": 578,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.584857,
+ "gbest_acc": 82.224
+ },
+ {
+ "epoch": 579,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.583669,
+ "gbest_acc": 82.19
+ },
+ {
+ "epoch": 580,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.583121,
+ "gbest_acc": 82.164
+ },
+ {
+ "epoch": 581,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.58292,
+ "gbest_acc": 82.292
+ },
+ {
+ "epoch": 582,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.581855,
+ "gbest_acc": 82.344
+ },
+ {
+ "epoch": 583,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.581213,
+ "gbest_acc": 82.388
+ },
+ {
+ "epoch": 584,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.580851,
+ "gbest_acc": 82.41
+ },
+ {
+ "epoch": 585,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.580264,
+ "gbest_acc": 82.366
+ },
+ {
+ "epoch": 586,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.580029,
+ "gbest_acc": 82.46
+ },
+ {
+ "epoch": 587,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.579905,
+ "gbest_acc": 82.466
+ },
+ {
+ "epoch": 588,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.579778,
+ "gbest_acc": 82.328
+ },
+ {
+ "epoch": 589,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.578577,
+ "gbest_acc": 82.528
+ },
+ {
+ "epoch": 590,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.578577,
+ "gbest_acc": 82.528
+ },
+ {
+ "epoch": 591,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.577439,
+ "gbest_acc": 82.504
+ },
+ {
+ "epoch": 592,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.576872,
+ "gbest_acc": 82.524
+ },
+ {
+ "epoch": 593,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.576643,
+ "gbest_acc": 82.518
+ },
+ {
+ "epoch": 594,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.576474,
+ "gbest_acc": 82.538
+ },
+ {
+ "epoch": 595,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.576085,
+ "gbest_acc": 82.558
+ },
+ {
+ "epoch": 596,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.575808,
+ "gbest_acc": 82.554
+ },
+ {
+ "epoch": 597,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.575494,
+ "gbest_acc": 82.568
+ },
+ {
+ "epoch": 598,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.57484,
+ "gbest_acc": 82.674
+ },
+ {
+ "epoch": 599,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.574466,
+ "gbest_acc": 82.632
+ },
+ {
+ "epoch": 600,
+ "stage": 2,
+ "subset_size": 50000,
+ "gbest_loss": 0.573398,
+ "gbest_acc": 82.608
+ }
+ ]
+ }
+ ],
+ "validation_summary": {
+ "best_pbest_nll": {
+ "mean": 0.592376,
+ "std": 0.018705,
+ "median": 0.59828,
+ "iqr": 0.017993,
+ "ci95_t": 0.046467
+ },
+ "best_pbest_accuracy": {
+ "mean": 82.34,
+ "std": 0.346987,
+ "median": 82.42,
+ "iqr": 0.34,
+ "ci95_t": 0.861973
+ },
+ "wall_time_sec": {
+ "mean": 149.6342,
+ "std": 21.528865,
+ "median": 160.2394,
+ "iqr": 19.4715,
+ "ci95_t": 53.481252
+ }
+ }
+ },
+ "final_endpoints": {
+ "single_model": {
+ "selected_seed": 103,
+ "selected_particle_idx": 54,
+ "model_fingerprint": "329e0a04039125fc",
+ "val_loss": 0.571431,
+ "val_acc": 82.64,
+ "selection_rule": "lowest_validation_nll_then_highest_accuracy",
+ "test_accuracy": 83.23,
+ "test_nll": 0.556332,
+ "test_brier": 0.253921,
+ "test_ece": 0.085242,
+ "test_margin": 0.611698
+ },
+ "ensemble": {
+ "ensemble_size": 5,
+ "members": [
+ {
+ "seed": 103,
+ "particle_idx": 54,
+ "val_loss": 0.571431,
+ "val_acc": 82.64
+ },
+ {
+ "seed": 102,
+ "particle_idx": 50,
+ "val_loss": 0.615358,
+ "val_acc": 81.64
+ },
+ {
+ "seed": 101,
+ "particle_idx": 48,
+ "val_loss": 0.601696,
+ "val_acc": 81.9
+ },
+ {
+ "seed": 102,
+ "particle_idx": 29,
+ "val_loss": 0.609323,
+ "val_acc": 82.16
+ },
+ {
+ "seed": 101,
+ "particle_idx": 22,
+ "val_loss": 0.601106,
+ "val_acc": 81.75
+ }
+ ],
+ "validation_accuracy": 86.6,
+ "validation_nll": 0.548785,
+ "validation_brier": 0.243377,
+ "validation_ece": 0.167913,
+ "validation_margin": 0.552753,
+ "validation_pairwise_disagreement": 0.16493,
+ "test_accuracy": 87.0,
+ "test_nll": 0.535928,
+ "test_brier": 0.236233,
+ "test_ece": 0.164284,
+ "test_margin": 0.561269,
+ "pairwise_disagreement": 0.1585
+ }
+ },
+ "accounting": {
+ "total_wall_time_sec": 473.4657,
+ "total_queries": 127560,
+ "total_sample_evaluations": 848400000,
+ "scope": "pilot_and_confirmation_training_objectives_including_transition_reevaluations; excludes validation and test"
+ },
+ "failure_record": null
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v6_heavy_autoresearch.csv b/benchmark_results/pso_v6_heavy_autoresearch.csv
new file mode 100644
index 0000000..8abc77a
--- /dev/null
+++ b/benchmark_results/pso_v6_heavy_autoresearch.csv
@@ -0,0 +1,9 @@
+workload,split,seeds,accuracy_mean,accuracy_sd,nll_mean,nll_sd,accuracy_gain_vs_baseline_pp,relative_nll_reduction_vs_baseline_pct,state_ratio,ratio,projection_mode,projection_seed
+mnist_compact,development_seeds_101_103,101-103,49.053333,0.417652,1.525704,0.01494,-0.1,-0.501617,0.4918032786885246,0.5,fixed,1800044939
+mnist_compact,confirmation_seeds_111_113,111-113,48.466667,2.515002,1.550212,0.046101,-0.686666,-2.116016,0.4918032786885246,0.5,fixed,1800044939
+mnist_wide,development_seeds_101_103,101-103,48.346667,3.214052,1.677712,0.072138,4.486667,2.52995,0.5,0.5,explicit,592157828
+mnist_wide,confirmation_seeds_111_113,111-113,45.723333,1.05633,1.734905,0.034461,1.863333,-0.792792,0.5,0.5,explicit,592157828
+fashion_compact,development_seeds_101_103,101-103,50.796667,3.095228,1.385324,0.035646,3.793334,8.330571,0.4918032786885246,0.5,fixed,1363313651
+fashion_compact,confirmation_seeds_111_113,111-113,53.196667,2.025669,1.328168,0.078488,6.193334,12.112688,0.4918032786885246,0.5,fixed,1363313651
+fashion_wide,development_seeds_101_103,101-103,48.263333,3.71862,1.531421,0.069986,1.953333,-0.371883,0.5,0.5,fixed,189641451
+fashion_wide,confirmation_seeds_111_113,111-113,49.476667,4.250251,1.513876,0.067096,3.166667,0.778045,0.5,0.5,fixed,189641451
diff --git a/benchmark_results/pso_v6_heavy_autoresearch.json b/benchmark_results/pso_v6_heavy_autoresearch.json
new file mode 100644
index 0000000..dcf0111
--- /dev/null
+++ b/benchmark_results/pso_v6_heavy_autoresearch.json
@@ -0,0 +1,1008 @@
+{
+ "protocol_version": "HEAVY-PSO-AUTORESEARCH-SUMMARY 1.0.0",
+ "timestamp": "2026-09-02T16:58:44.813352Z",
+ "mission": "Improve robust validation-quality/resource-efficiency Pareto frontier across four heavy PSO workloads",
+ "baseline_artifact": "benchmark_results/pso_v6_heavy_tasks.json",
+ "official_test_data_loaded": false,
+ "official_test_evaluations": 0,
+ "fixed_budget": {
+ "particles": 12,
+ "epochs": 80,
+ "fitness_subset_size": 10000,
+ "queries_per_run": 960,
+ "sample_evaluations_per_run": 9600000
+ },
+ "retained_development_policy": {
+ "candidate_id": "fixed_global_hybrid_v3",
+ "artifact": ".omc/autoresearch/heavy-pso-progressive-improvement/runs/20260902T153426Z/candidates/iteration-0008-development.json",
+ "evaluation_artifact": ".omc/autoresearch/heavy-pso-progressive-improvement/runs/20260902T153426Z/evaluations/iteration-0008-development.json",
+ "pass": true,
+ "score": 15.030088553498544,
+ "gate_details": {
+ "gate_finite": true,
+ "gate_test_sealed": true,
+ "gate_config_matched": true,
+ "gate_state_ratio": true,
+ "gate_acc_regression": true,
+ "gate_nll_regression": true,
+ "gate_baseline_worst_improvement": true
+ },
+ "summary_metrics": {
+ "mean_rel_nll_reduction_pct": 2.4967550534985445,
+ "mean_acc_gain_pp": 2.5333334999999995,
+ "max_state_ratio": 0.5,
+ "state_efficiency_bonus": 10.0
+ }
+ },
+ "independent_confirmation": {
+ "candidate_id": "fixed_global_hybrid_v3_confirmation",
+ "seeds": [
+ 111,
+ 112,
+ 113
+ ],
+ "artifact": ".omc/autoresearch/heavy-pso-progressive-improvement/runs/20260902T153426Z/candidates/iteration-0008.json",
+ "evaluation_artifact": ".omc/autoresearch/heavy-pso-progressive-improvement/runs/20260902T153426Z/evaluations/iteration-0008.json",
+ "pass": false,
+ "score": -84.8703515707342,
+ "failed_gates": [
+ "gate_baseline_worst_improvement"
+ ],
+ "gate_details": {
+ "gate_finite": true,
+ "gate_test_sealed": true,
+ "gate_config_matched_for_confirmation_seeds": true,
+ "gate_state_ratio": true,
+ "gate_acc_regression": true,
+ "gate_nll_regression": true,
+ "gate_baseline_worst_improvement": false
+ },
+ "summary_metrics": {
+ "mean_rel_nll_reduction_pct": 2.4954814292658,
+ "mean_acc_gain_pp": 2.634166999999998,
+ "max_state_ratio": 0.5,
+ "state_efficiency_bonus": 10.0
+ },
+ "interpretation": "All gates except MNIST Wide >=2pp or >=5% NLL improvement passed; MNIST Wide accuracy gain was 1.863333pp."
+ },
+ "workloads": {
+ "mnist_compact": {
+ "configuration": {
+ "ratio": 0.5,
+ "projection_mode": "fixed",
+ "projection_seed": 1800044939
+ },
+ "baseline": {
+ "acc": 49.153333,
+ "nll": 1.518089
+ },
+ "development_seeds_101_103": {
+ "accuracy_mean": 49.053333,
+ "accuracy_sd": 0.417652,
+ "nll_mean": 1.525704,
+ "nll_sd": 0.01494,
+ "state_ratio": 0.4918032786885246,
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "projection_seed": 1800044939,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.508496,
+ "val_selected_acc": 49.37,
+ "val_metrics": {
+ "accuracy": 49.37,
+ "nll": 1.508496,
+ "brier": 0.661818,
+ "ece": 0.059748,
+ "margin": 0.242134
+ },
+ "gbest_loss": 1.500976,
+ "gbest_acc": 49.96,
+ "wall_time_sec": 4.1926,
+ "optimization_wall_time_sec": 4.0964,
+ "validation_wall_time_sec": 0.0962,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 2343521.14,
+ "is_finite": true
+ },
+ {
+ "seed": 102,
+ "projection_seed": 1800044939,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.535355,
+ "val_selected_acc": 48.58,
+ "val_metrics": {
+ "accuracy": 48.58,
+ "nll": 1.535355,
+ "brier": 0.67486,
+ "ece": 0.040094,
+ "margin": 0.256588
+ },
+ "gbest_loss": 1.538532,
+ "gbest_acc": 49.1,
+ "wall_time_sec": 4.0102,
+ "optimization_wall_time_sec": 3.9255,
+ "validation_wall_time_sec": 0.0847,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 2445548.34,
+ "is_finite": true
+ },
+ {
+ "seed": 103,
+ "projection_seed": 1800044939,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.533262,
+ "val_selected_acc": 49.21,
+ "val_metrics": {
+ "accuracy": 49.21,
+ "nll": 1.533262,
+ "brier": 0.677455,
+ "ece": 0.106045,
+ "margin": 0.189773
+ },
+ "gbest_loss": 1.533525,
+ "gbest_acc": 49.09,
+ "wall_time_sec": 4.122,
+ "optimization_wall_time_sec": 4.0346,
+ "validation_wall_time_sec": 0.0874,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 2379418.03,
+ "is_finite": true
+ }
+ ]
+ },
+ "confirmation_seeds_111_113": {
+ "accuracy_mean": 48.466667,
+ "accuracy_sd": 2.515002,
+ "nll_mean": 1.550212,
+ "nll_sd": 0.046101,
+ "state_ratio": 0.4918032786885246,
+ "per_seed_runs": [
+ {
+ "seed": 111,
+ "projection_seed": 1800044939,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.49861,
+ "val_selected_acc": 50.98,
+ "val_metrics": {
+ "accuracy": 50.98,
+ "nll": 1.49861,
+ "brier": 0.6511,
+ "ece": 0.10158,
+ "margin": 0.22606
+ },
+ "gbest_loss": 1.49346,
+ "gbest_acc": 51.43,
+ "wall_time_sec": 4.1571,
+ "optimization_wall_time_sec": 4.067,
+ "validation_wall_time_sec": 0.0901,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 2360462.26,
+ "is_finite": true
+ },
+ {
+ "seed": 112,
+ "projection_seed": 1800044939,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.587337,
+ "val_selected_acc": 45.95,
+ "val_metrics": {
+ "accuracy": 45.95,
+ "nll": 1.587337,
+ "brier": 0.708292,
+ "ece": 0.078185,
+ "margin": 0.188558
+ },
+ "gbest_loss": 1.604532,
+ "gbest_acc": 45.63,
+ "wall_time_sec": 4.0905,
+ "optimization_wall_time_sec": 4.004,
+ "validation_wall_time_sec": 0.0865,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 2397602.4,
+ "is_finite": true
+ },
+ {
+ "seed": 113,
+ "projection_seed": 1800044939,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.564689,
+ "val_selected_acc": 48.47,
+ "val_metrics": {
+ "accuracy": 48.47,
+ "nll": 1.564689,
+ "brier": 0.686774,
+ "ece": 0.080412,
+ "margin": 0.215579
+ },
+ "gbest_loss": 1.559706,
+ "gbest_acc": 48.72,
+ "wall_time_sec": 4.0765,
+ "optimization_wall_time_sec": 3.9899,
+ "validation_wall_time_sec": 0.0866,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 2406075.34,
+ "is_finite": true
+ }
+ ]
+ },
+ "pooled_six_seed_descriptive": {
+ "accuracy_mean": 48.76,
+ "accuracy_sd": 1.644117,
+ "nll_mean": 1.537958,
+ "nll_sd": 0.03346,
+ "accuracy_gain_vs_baseline_pp": -0.393333,
+ "relative_nll_reduction_vs_baseline_pct": -1.308828
+ }
+ },
+ "mnist_wide": {
+ "configuration": {
+ "ratio": 0.5,
+ "projection_mode": "explicit",
+ "projection_seed": 592157828
+ },
+ "baseline": {
+ "acc": 43.86,
+ "nll": 1.721259
+ },
+ "development_seeds_101_103": {
+ "accuracy_mean": 48.346667,
+ "accuracy_sd": 3.214052,
+ "nll_mean": 1.677712,
+ "nll_sd": 0.072138,
+ "state_ratio": 0.5,
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "projection_seed": 592157828,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "explicit",
+ "val_selected_loss": 1.623417,
+ "val_selected_acc": 48.0,
+ "val_metrics": {
+ "accuracy": 48.0,
+ "nll": 1.623417,
+ "brier": 0.708517,
+ "ece": 0.166082,
+ "margin": 0.12829
+ },
+ "gbest_loss": 1.626397,
+ "gbest_acc": 47.44,
+ "wall_time_sec": 9.0689,
+ "optimization_wall_time_sec": 8.8759,
+ "validation_wall_time_sec": 0.193,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 1081580.46,
+ "is_finite": true
+ },
+ {
+ "seed": 102,
+ "projection_seed": 592157828,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "explicit",
+ "val_selected_loss": 1.650152,
+ "val_selected_acc": 51.72,
+ "val_metrics": {
+ "accuracy": 51.72,
+ "nll": 1.650152,
+ "brier": 0.684201,
+ "ece": 0.187814,
+ "margin": 0.162795
+ },
+ "gbest_loss": 1.651721,
+ "gbest_acc": 51.51,
+ "wall_time_sec": 8.9599,
+ "optimization_wall_time_sec": 8.7709,
+ "validation_wall_time_sec": 0.189,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 1094528.5,
+ "is_finite": true
+ },
+ {
+ "seed": 103,
+ "projection_seed": 592157828,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "explicit",
+ "val_selected_loss": 1.759568,
+ "val_selected_acc": 45.32,
+ "val_metrics": {
+ "accuracy": 45.32,
+ "nll": 1.759568,
+ "brier": 0.746379,
+ "ece": 0.172542,
+ "margin": 0.114347
+ },
+ "gbest_loss": 1.765249,
+ "gbest_acc": 45.42,
+ "wall_time_sec": 9.0561,
+ "optimization_wall_time_sec": 8.8638,
+ "validation_wall_time_sec": 0.1922,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 1083056.93,
+ "is_finite": true
+ }
+ ]
+ },
+ "confirmation_seeds_111_113": {
+ "accuracy_mean": 45.723333,
+ "accuracy_sd": 1.05633,
+ "nll_mean": 1.734905,
+ "nll_sd": 0.034461,
+ "state_ratio": 0.5,
+ "per_seed_runs": [
+ {
+ "seed": 111,
+ "projection_seed": 592157828,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "explicit",
+ "val_selected_loss": 1.774538,
+ "val_selected_acc": 45.04,
+ "val_metrics": {
+ "accuracy": 45.04,
+ "nll": 1.774538,
+ "brier": 0.750548,
+ "ece": 0.180957,
+ "margin": 0.105995
+ },
+ "gbest_loss": 1.776591,
+ "gbest_acc": 45.8,
+ "wall_time_sec": 9.1173,
+ "optimization_wall_time_sec": 8.9223,
+ "validation_wall_time_sec": 0.195,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 1075955.75,
+ "is_finite": true
+ },
+ {
+ "seed": 112,
+ "projection_seed": 592157828,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "explicit",
+ "val_selected_loss": 1.718164,
+ "val_selected_acc": 45.19,
+ "val_metrics": {
+ "accuracy": 45.19,
+ "nll": 1.718164,
+ "brier": 0.744937,
+ "ece": 0.160644,
+ "margin": 0.130123
+ },
+ "gbest_loss": 1.720852,
+ "gbest_acc": 45.65,
+ "wall_time_sec": 9.0242,
+ "optimization_wall_time_sec": 8.831,
+ "validation_wall_time_sec": 0.1932,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 1087079.61,
+ "is_finite": true
+ },
+ {
+ "seed": 113,
+ "projection_seed": 592157828,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "explicit",
+ "val_selected_loss": 1.712013,
+ "val_selected_acc": 46.94,
+ "val_metrics": {
+ "accuracy": 46.94,
+ "nll": 1.712013,
+ "brier": 0.726372,
+ "ece": 0.173083,
+ "margin": 0.130682
+ },
+ "gbest_loss": 1.722324,
+ "gbest_acc": 46.54,
+ "wall_time_sec": 9.0238,
+ "optimization_wall_time_sec": 8.8321,
+ "validation_wall_time_sec": 0.1917,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 1086944.21,
+ "is_finite": true
+ }
+ ]
+ },
+ "pooled_six_seed_descriptive": {
+ "accuracy_mean": 47.035,
+ "accuracy_sd": 2.577392,
+ "nll_mean": 1.706309,
+ "nll_sd": 0.05948,
+ "accuracy_gain_vs_baseline_pp": 3.175,
+ "relative_nll_reduction_vs_baseline_pct": 0.86857
+ }
+ },
+ "fashion_compact": {
+ "configuration": {
+ "ratio": 0.5,
+ "projection_mode": "fixed",
+ "projection_seed": 1363313651
+ },
+ "baseline": {
+ "acc": 47.003333,
+ "nll": 1.511217
+ },
+ "development_seeds_101_103": {
+ "accuracy_mean": 50.796667,
+ "accuracy_sd": 3.095228,
+ "nll_mean": 1.385324,
+ "nll_sd": 0.035646,
+ "state_ratio": 0.4918032786885246,
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "projection_seed": 1363313651,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.354168,
+ "val_selected_acc": 53.87,
+ "val_metrics": {
+ "accuracy": 53.87,
+ "nll": 1.354168,
+ "brier": 0.602951,
+ "ece": 0.038927,
+ "margin": 0.311583
+ },
+ "gbest_loss": 1.343266,
+ "gbest_acc": 54.57,
+ "wall_time_sec": 4.8428,
+ "optimization_wall_time_sec": 4.7407,
+ "validation_wall_time_sec": 0.1021,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 2025017.4,
+ "is_finite": true
+ },
+ {
+ "seed": 102,
+ "projection_seed": 1363313651,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.377608,
+ "val_selected_acc": 50.84,
+ "val_metrics": {
+ "accuracy": 50.84,
+ "nll": 1.377608,
+ "brier": 0.627903,
+ "ece": 0.032173,
+ "margin": 0.277591
+ },
+ "gbest_loss": 1.374537,
+ "gbest_acc": 51.05,
+ "wall_time_sec": 5.7967,
+ "optimization_wall_time_sec": 5.6875,
+ "validation_wall_time_sec": 0.1092,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 1687912.09,
+ "is_finite": true
+ },
+ {
+ "seed": 103,
+ "projection_seed": 1363313651,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.424197,
+ "val_selected_acc": 47.68,
+ "val_metrics": {
+ "accuracy": 47.68,
+ "nll": 1.424197,
+ "brier": 0.658571,
+ "ece": 0.021549,
+ "margin": 0.268061
+ },
+ "gbest_loss": 1.426838,
+ "gbest_acc": 47.3,
+ "wall_time_sec": 4.7604,
+ "optimization_wall_time_sec": 4.6591,
+ "validation_wall_time_sec": 0.1013,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 2060483.78,
+ "is_finite": true
+ }
+ ]
+ },
+ "confirmation_seeds_111_113": {
+ "accuracy_mean": 53.196667,
+ "accuracy_sd": 2.025669,
+ "nll_mean": 1.328168,
+ "nll_sd": 0.078488,
+ "state_ratio": 0.4918032786885246,
+ "per_seed_runs": [
+ {
+ "seed": 111,
+ "projection_seed": 1363313651,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.280875,
+ "val_selected_acc": 53.83,
+ "val_metrics": {
+ "accuracy": 53.83,
+ "nll": 1.280875,
+ "brier": 0.599374,
+ "ece": 0.040911,
+ "margin": 0.289031
+ },
+ "gbest_loss": 1.29506,
+ "gbest_acc": 52.88,
+ "wall_time_sec": 4.5221,
+ "optimization_wall_time_sec": 4.4262,
+ "validation_wall_time_sec": 0.0959,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 2168903.35,
+ "is_finite": true
+ },
+ {
+ "seed": 112,
+ "projection_seed": 1363313651,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.284859,
+ "val_selected_acc": 54.83,
+ "val_metrics": {
+ "accuracy": 54.83,
+ "nll": 1.284859,
+ "brier": 0.588788,
+ "ece": 0.011783,
+ "margin": 0.363813
+ },
+ "gbest_loss": 1.281715,
+ "gbest_acc": 54.62,
+ "wall_time_sec": 4.5253,
+ "optimization_wall_time_sec": 4.4291,
+ "validation_wall_time_sec": 0.0962,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 2167483.24,
+ "is_finite": true
+ },
+ {
+ "seed": 113,
+ "projection_seed": 1363313651,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.418769,
+ "val_selected_acc": 50.93,
+ "val_metrics": {
+ "accuracy": 50.93,
+ "nll": 1.418769,
+ "brier": 0.637337,
+ "ece": 0.047296,
+ "margin": 0.262931
+ },
+ "gbest_loss": 1.394867,
+ "gbest_acc": 51.93,
+ "wall_time_sec": 4.5414,
+ "optimization_wall_time_sec": 4.4438,
+ "validation_wall_time_sec": 0.0976,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 1091760,
+ "throughput_samples_per_sec": 2160313.25,
+ "is_finite": true
+ }
+ ]
+ },
+ "pooled_six_seed_descriptive": {
+ "accuracy_mean": 51.996667,
+ "accuracy_sd": 2.683562,
+ "nll_mean": 1.356746,
+ "nll_sd": 0.062869,
+ "accuracy_gain_vs_baseline_pp": 4.993334,
+ "relative_nll_reduction_vs_baseline_pct": 10.221629
+ }
+ },
+ "fashion_wide": {
+ "configuration": {
+ "ratio": 0.5,
+ "projection_mode": "fixed",
+ "projection_seed": 189641451
+ },
+ "baseline": {
+ "acc": 46.31,
+ "nll": 1.525747
+ },
+ "development_seeds_101_103": {
+ "accuracy_mean": 48.263333,
+ "accuracy_sd": 3.71862,
+ "nll_mean": 1.531421,
+ "nll_sd": 0.069986,
+ "state_ratio": 0.5,
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "projection_seed": 189641451,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.45314,
+ "val_selected_acc": 52.51,
+ "val_metrics": {
+ "accuracy": 52.51,
+ "nll": 1.45314,
+ "brier": 0.64443,
+ "ece": 0.127916,
+ "margin": 0.203178
+ },
+ "gbest_loss": 1.448002,
+ "gbest_acc": 53.03,
+ "wall_time_sec": 10.4888,
+ "optimization_wall_time_sec": 10.261,
+ "validation_wall_time_sec": 0.2277,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 935581.33,
+ "is_finite": true
+ },
+ {
+ "seed": 102,
+ "projection_seed": 189641451,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.553182,
+ "val_selected_acc": 46.69,
+ "val_metrics": {
+ "accuracy": 46.69,
+ "nll": 1.553182,
+ "brier": 0.700904,
+ "ece": 0.135106,
+ "margin": 0.138265
+ },
+ "gbest_loss": 1.561158,
+ "gbest_acc": 46.59,
+ "wall_time_sec": 10.6202,
+ "optimization_wall_time_sec": 10.3968,
+ "validation_wall_time_sec": 0.2233,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 923361.03,
+ "is_finite": true
+ },
+ {
+ "seed": 103,
+ "projection_seed": 189641451,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.587942,
+ "val_selected_acc": 45.59,
+ "val_metrics": {
+ "accuracy": 45.59,
+ "nll": 1.587942,
+ "brier": 0.712462,
+ "ece": 0.153597,
+ "margin": 0.107177
+ },
+ "gbest_loss": 1.592958,
+ "gbest_acc": 45.53,
+ "wall_time_sec": 10.3262,
+ "optimization_wall_time_sec": 10.1108,
+ "validation_wall_time_sec": 0.2154,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 949479.76,
+ "is_finite": true
+ }
+ ]
+ },
+ "confirmation_seeds_111_113": {
+ "accuracy_mean": 49.476667,
+ "accuracy_sd": 4.250251,
+ "nll_mean": 1.513876,
+ "nll_sd": 0.067096,
+ "state_ratio": 0.5,
+ "per_seed_runs": [
+ {
+ "seed": 111,
+ "projection_seed": 189641451,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.571807,
+ "val_selected_acc": 44.57,
+ "val_metrics": {
+ "accuracy": 44.57,
+ "nll": 1.571807,
+ "brier": 0.71508,
+ "ece": 0.137347,
+ "margin": 0.098194
+ },
+ "gbest_loss": 1.565421,
+ "gbest_acc": 44.63,
+ "wall_time_sec": 9.0783,
+ "optimization_wall_time_sec": 8.8852,
+ "validation_wall_time_sec": 0.1931,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 1080448.39,
+ "is_finite": true
+ },
+ {
+ "seed": 112,
+ "projection_seed": 189641451,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.529463,
+ "val_selected_acc": 51.84,
+ "val_metrics": {
+ "accuracy": 51.84,
+ "nll": 1.529463,
+ "brier": 0.667654,
+ "ece": 0.123789,
+ "margin": 0.207157
+ },
+ "gbest_loss": 1.520432,
+ "gbest_acc": 52.76,
+ "wall_time_sec": 8.9695,
+ "optimization_wall_time_sec": 8.78,
+ "validation_wall_time_sec": 0.1895,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 1093394.08,
+ "is_finite": true
+ },
+ {
+ "seed": 113,
+ "projection_seed": 189641451,
+ "projection_salt": "",
+ "projection_scope": "global",
+ "projection_seed_mode": "fixed",
+ "val_selected_loss": 1.440358,
+ "val_selected_acc": 52.02,
+ "val_metrics": {
+ "accuracy": 52.02,
+ "nll": 1.440358,
+ "brier": 0.64715,
+ "ece": 0.129255,
+ "margin": 0.198592
+ },
+ "gbest_loss": 1.427173,
+ "gbest_acc": 52.41,
+ "wall_time_sec": 8.9934,
+ "optimization_wall_time_sec": 8.8035,
+ "validation_wall_time_sec": 0.1899,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 6640560,
+ "throughput_samples_per_sec": 1090475.38,
+ "is_finite": true
+ }
+ ]
+ },
+ "pooled_six_seed_descriptive": {
+ "accuracy_mean": 48.87,
+ "accuracy_sd": 3.63301,
+ "nll_mean": 1.522649,
+ "nll_sd": 0.062067,
+ "accuracy_gain_vs_baseline_pp": 2.56,
+ "relative_nll_reduction_vs_baseline_pct": 0.20307
+ }
+ }
+ },
+ "rejected_methods": [
+ "single shared global-hash ratio",
+ "projection-coupled workload-adaptive policy as robust",
+ "tensor-local proportional signed hashing",
+ "geometry multipliers 0.75 and 0.5"
+ ],
+ "resource_totals": {
+ "executed_runs": 312,
+ "total_queries": 299520,
+ "total_sample_evaluations": 2995200000,
+ "total_wall_time_sec": 2264.4978
+ },
+ "decision_log": ".omc/autoresearch/heavy-pso-progressive-improvement/runs/20260902T153426Z/decision-log.md",
+ "evaluator_contract": {
+ "version": "HEAVY-PSO-PARETO-EVALUATOR 1.0.0",
+ "command": "uv run --no-sync python test/evaluate_heavy_autoresearch.py --baseline benchmark_results/pso_v6_heavy_tasks.json --candidate --output ",
+ "required_output": {
+ "pass": "boolean",
+ "score": "number"
+ },
+ "baseline_policy": {
+ "mnist_compact": "G8",
+ "mnist_wide": "G5",
+ "fashion_compact": "G8",
+ "fashion_wide": "G5"
+ },
+ "matched_confirmation": {
+ "particles": 12,
+ "epochs": 80,
+ "objective_subset_size": 10000,
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ]
+ },
+ "hard_gates": {
+ "all_runs_finite": true,
+ "official_test_data_loaded": false,
+ "official_test_evaluations": 0,
+ "maximum_state_ratio_each_workload": 0.5,
+ "maximum_accuracy_regression_percentage_points_each_workload": 1.0,
+ "maximum_nll_regression_fraction_each_workload": 0.05,
+ "worst_baseline_workload": "mnist_wide",
+ "worst_workload_minimum_accuracy_gain_percentage_points": 2.0,
+ "worst_workload_minimum_nll_reduction_fraction": 0.05,
+ "worst_workload_improvement_logic": "accuracy_gain_or_nll_reduction"
+ },
+ "score": {
+ "formula": "mean_relative_nll_reduction_pct + mean_accuracy_gain_pp + 10*log2(1/max_state_ratio) - 100*failed_hard_gate_count",
+ "higher_is_better": true
+ }
+ },
+ "iteration_outcomes": [
+ {
+ "iteration": 1,
+ "method": "equalized global signed-hash ratios, recovered geometry",
+ "pass": false,
+ "selected_score": -159.733422,
+ "decision": "rejected"
+ },
+ {
+ "iteration": 2,
+ "method": "baseline-aligned geometry diagnostics",
+ "pass": false,
+ "selected_score": -154.242035,
+ "decision": "geometry mismatch resolved"
+ },
+ {
+ "iteration": 3,
+ "method": "workload-adaptive projection-coupled policy",
+ "pass": true,
+ "selected_score": 12.052443,
+ "decision": "provisional; projection replica required"
+ },
+ {
+ "iteration": 4,
+ "method": "independent projection replica",
+ "pass": false,
+ "selected_score": -189.945268,
+ "decision": "projection-fragile"
+ },
+ {
+ "iteration": 5,
+ "method": "tensor-local signed hashing",
+ "pass": false,
+ "selected_score": -274.949828,
+ "decision": "rejected"
+ },
+ {
+ "iteration": 6,
+ "method": "fixed projection across swarm seeds",
+ "pass": false,
+ "selected_score": -181.504378,
+ "decision": "three cells retained; MNIST Wide unresolved"
+ },
+ {
+ "iteration": 7,
+ "method": "explicit MNIST Wide projection confirmation",
+ "pass": true,
+ "selected_score": 15.550961,
+ "decision": "development pass; disjoint seeds required"
+ },
+ {
+ "iteration": 8,
+ "method": "fixed global hybrid v3 plus disjoint swarm seeds",
+ "pass": false,
+ "selected_score": -84.870352,
+ "decision": "development pass; confirmation missed one gate"
+ },
+ {
+ "iteration": 9,
+ "method": "geometry multipliers 0.75 and 0.5",
+ "pass": false,
+ "selected_score": -290.662892,
+ "decision": "rejected; stop branch"
+ }
+ ]
+}
diff --git a/benchmark_results/pso_v6_heavy_tasks.csv b/benchmark_results/pso_v6_heavy_tasks.csv
new file mode 100644
index 0000000..8aee5b2
--- /dev/null
+++ b/benchmark_results/pso_v6_heavy_tasks.csv
@@ -0,0 +1,164 @@
+section,workload,method,metric,value
+protocol,global,all,version,HEAVY-TASK-PSO-V6 1.0.0
+protocol,global,all,official_test_data_loaded,False
+protocol,global,all,official_test_evaluations,0
+baseline,mnist_compact,untrained,val_nll,2.325095
+baseline,mnist_compact,untrained,val_accuracy,6.65
+baseline,mnist_wide,untrained,val_nll,2.32458
+baseline,mnist_wide,untrained,val_accuracy,9.31
+baseline,fashion_compact,untrained,val_nll,2.320302
+baseline,fashion_compact,untrained,val_accuracy,8.08
+baseline,fashion_wide,untrained,val_nll,2.311222
+baseline,fashion_wide,untrained,val_accuracy,8.77
+screen,mnist_compact,G0,val_nll,2.019988
+screen,mnist_compact,G0,val_acc,33.32
+screen,mnist_compact,G0,gbest_loss,2.014459
+screen,mnist_compact,G0,gbest_acc,34.4
+screen,mnist_compact,G0,throughput_sps,1106883.43
+screen,mnist_compact,G5,val_nll,1.959743
+screen,mnist_compact,G5,val_acc,33.95
+screen,mnist_compact,G5,gbest_loss,1.971574
+screen,mnist_compact,G5,gbest_acc,32.35
+screen,mnist_compact,G5,throughput_sps,1139465.88
+screen,mnist_compact,G6,val_nll,1.957307
+screen,mnist_compact,G6,val_acc,35.11
+screen,mnist_compact,G6,gbest_loss,1.941859
+screen,mnist_compact,G6,gbest_acc,35.35
+screen,mnist_compact,G6,throughput_sps,1340969.41
+screen,mnist_compact,G8,val_nll,1.690442
+screen,mnist_compact,G8,val_acc,43.88
+screen,mnist_compact,G8,gbest_loss,1.675063
+screen,mnist_compact,G8,gbest_acc,43.6
+screen,mnist_compact,G8,throughput_sps,984615.38
+screen,mnist_wide,G0,val_nll,2.088156
+screen,mnist_wide,G0,val_acc,33.19
+screen,mnist_wide,G0,gbest_loss,2.087951
+screen,mnist_wide,G0,gbest_acc,32.45
+screen,mnist_wide,G0,throughput_sps,595459.62
+screen,mnist_wide,G5,val_nll,1.913566
+screen,mnist_wide,G5,val_acc,39.87
+screen,mnist_wide,G5,gbest_loss,1.924357
+screen,mnist_wide,G5,gbest_acc,39.5
+screen,mnist_wide,G5,throughput_sps,772511.47
+screen,mnist_wide,G6,val_nll,2.017511
+screen,mnist_wide,G6,val_acc,29.46
+screen,mnist_wide,G6,gbest_loss,2.014518
+screen,mnist_wide,G6,gbest_acc,27.8
+screen,mnist_wide,G6,throughput_sps,777013.35
+screen,mnist_wide,G8,val_nll,2.056341
+screen,mnist_wide,G8,val_acc,20.43
+screen,mnist_wide,G8,gbest_loss,2.062368
+screen,mnist_wide,G8,gbest_acc,20.3
+screen,mnist_wide,G8,throughput_sps,855005.34
+screen,fashion_compact,G0,val_nll,1.969548
+screen,fashion_compact,G0,val_acc,28.25
+screen,fashion_compact,G0,gbest_loss,1.96974
+screen,fashion_compact,G0,gbest_acc,28.15
+screen,fashion_compact,G0,throughput_sps,1219977.13
+screen,fashion_compact,G5,val_nll,1.892402
+screen,fashion_compact,G5,val_acc,34.31
+screen,fashion_compact,G5,gbest_loss,1.874629
+screen,fashion_compact,G5,gbest_acc,36.6
+screen,fashion_compact,G5,throughput_sps,1122281.97
+screen,fashion_compact,G6,val_nll,1.824273
+screen,fashion_compact,G6,val_acc,35.2
+screen,fashion_compact,G6,gbest_loss,1.844914
+screen,fashion_compact,G6,gbest_acc,33.5
+screen,fashion_compact,G6,throughput_sps,1152322.65
+screen,fashion_compact,G8,val_nll,1.88018
+screen,fashion_compact,G8,val_acc,30.85
+screen,fashion_compact,G8,gbest_loss,1.895269
+screen,fashion_compact,G8,gbest_acc,28.85
+screen,fashion_compact,G8,throughput_sps,1193139.45
+screen,fashion_wide,G0,val_nll,1.981316
+screen,fashion_wide,G0,val_acc,36.39
+screen,fashion_wide,G0,gbest_loss,1.98436
+screen,fashion_wide,G0,gbest_acc,36.05
+screen,fashion_wide,G0,throughput_sps,540327.57
+screen,fashion_wide,G5,val_nll,1.945862
+screen,fashion_wide,G5,val_acc,31.97
+screen,fashion_wide,G5,gbest_loss,1.938569
+screen,fashion_wide,G5,gbest_acc,33.3
+screen,fashion_wide,G5,throughput_sps,807401.18
+screen,fashion_wide,G6,val_nll,1.975825
+screen,fashion_wide,G6,val_acc,28.64
+screen,fashion_wide,G6,gbest_loss,1.960139
+screen,fashion_wide,G6,gbest_acc,28.1
+screen,fashion_wide,G6,throughput_sps,735350.44
+screen,fashion_wide,G8,val_nll,1.987923
+screen,fashion_wide,G8,val_acc,28.69
+screen,fashion_wide,G8,gbest_loss,1.976977
+screen,fashion_wide,G8,gbest_acc,28.45
+screen,fashion_wide,G8,throughput_sps,865800.87
+confirm,mnist_compact,G8,val_acc_mean,49.153333
+confirm,mnist_compact,G8,val_acc_std,1.320656
+confirm,mnist_compact,G8,val_nll_mean,1.518089
+confirm,mnist_compact,G8,val_nll_std,0.061523
+confirm,mnist_compact,G8,wall_time_sec_mean,4.530167
+confirm,mnist_compact,G6,val_acc_mean,45.966667
+confirm,mnist_compact,G6,val_acc_std,3.545438
+confirm,mnist_compact,G6,val_nll_mean,1.642081
+confirm,mnist_compact,G6,val_nll_std,0.091398
+confirm,mnist_compact,G6,wall_time_sec_mean,5.2706
+confirm,mnist_wide,G8,val_acc_mean,41.03
+confirm,mnist_wide,G8,val_acc_std,4.055083
+confirm,mnist_wide,G8,val_nll_mean,1.733351
+confirm,mnist_wide,G8,val_nll_std,0.084331
+confirm,mnist_wide,G8,wall_time_sec_mean,9.4569
+confirm,mnist_wide,G5,val_acc_mean,43.86
+confirm,mnist_wide,G5,val_acc_std,3.512222
+confirm,mnist_wide,G5,val_nll_mean,1.721259
+confirm,mnist_wide,G5,val_nll_std,0.098656
+confirm,mnist_wide,G5,wall_time_sec_mean,9.868467
+confirm,fashion_compact,G8,val_acc_mean,47.003333
+confirm,fashion_compact,G8,val_acc_std,5.2259
+confirm,fashion_compact,G8,val_nll_mean,1.511217
+confirm,fashion_compact,G8,val_nll_std,0.168628
+confirm,fashion_compact,G8,wall_time_sec_mean,5.0146
+confirm,fashion_compact,G6,val_acc_mean,45.616667
+confirm,fashion_compact,G6,val_acc_std,3.585392
+confirm,fashion_compact,G6,val_nll_mean,1.584443
+confirm,fashion_compact,G6,val_nll_std,0.053077
+confirm,fashion_compact,G6,wall_time_sec_mean,4.839267
+confirm,fashion_wide,G8,val_acc_mean,41.666667
+confirm,fashion_wide,G8,val_acc_std,2.269016
+confirm,fashion_wide,G8,val_nll_mean,1.615937
+confirm,fashion_wide,G8,val_nll_std,0.036692
+confirm,fashion_wide,G8,wall_time_sec_mean,9.499333
+confirm,fashion_wide,G5,val_acc_mean,46.31
+confirm,fashion_wide,G5,val_acc_std,7.568494
+confirm,fashion_wide,G5,val_nll_mean,1.525747
+confirm,fashion_wide,G5,val_nll_std,0.149706
+confirm,fashion_wide,G5,wall_time_sec_mean,10.038833
+feasibility,mnist_compact,G8,execution_feasible,True
+feasibility,mnist_compact,G8,optimization_feasible,True
+feasibility,mnist_compact,G8,mean_val_nll,1.518089
+feasibility,mnist_compact,G8,mean_val_acc,49.1533
+feasibility,mnist_compact,G6,execution_feasible,True
+feasibility,mnist_compact,G6,optimization_feasible,True
+feasibility,mnist_compact,G6,mean_val_nll,1.642081
+feasibility,mnist_compact,G6,mean_val_acc,45.9667
+feasibility,mnist_wide,G8,execution_feasible,True
+feasibility,mnist_wide,G8,optimization_feasible,True
+feasibility,mnist_wide,G8,mean_val_nll,1.733351
+feasibility,mnist_wide,G8,mean_val_acc,41.03
+feasibility,mnist_wide,G5,execution_feasible,True
+feasibility,mnist_wide,G5,optimization_feasible,True
+feasibility,mnist_wide,G5,mean_val_nll,1.721259
+feasibility,mnist_wide,G5,mean_val_acc,43.86
+feasibility,fashion_compact,G8,execution_feasible,True
+feasibility,fashion_compact,G8,optimization_feasible,True
+feasibility,fashion_compact,G8,mean_val_nll,1.511217
+feasibility,fashion_compact,G8,mean_val_acc,47.0033
+feasibility,fashion_compact,G6,execution_feasible,True
+feasibility,fashion_compact,G6,optimization_feasible,True
+feasibility,fashion_compact,G6,mean_val_nll,1.584443
+feasibility,fashion_compact,G6,mean_val_acc,45.6167
+feasibility,fashion_wide,G8,execution_feasible,True
+feasibility,fashion_wide,G8,optimization_feasible,True
+feasibility,fashion_wide,G8,mean_val_nll,1.615937
+feasibility,fashion_wide,G8,mean_val_acc,41.6667
+feasibility,fashion_wide,G5,execution_feasible,True
+feasibility,fashion_wide,G5,optimization_feasible,True
+feasibility,fashion_wide,G5,mean_val_nll,1.525747
+feasibility,fashion_wide,G5,mean_val_acc,46.31
diff --git a/benchmark_results/pso_v6_heavy_tasks.json b/benchmark_results/pso_v6_heavy_tasks.json
new file mode 100644
index 0000000..17ce556
--- /dev/null
+++ b/benchmark_results/pso_v6_heavy_tasks.json
@@ -0,0 +1,2080 @@
+{
+ "protocol_version": "HEAVY-TASK-PSO-V6 1.0.0",
+ "timestamp": "2026-09-02T14:52:52Z",
+ "hardware": {
+ "platform": "macOS-26.6.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "pso_version": "4.0.0",
+ "official_test_data_loaded": false,
+ "official_test_evaluations": 0,
+ "study_design": {
+ "screen": {
+ "methods": [
+ "G0",
+ "G5",
+ "G6",
+ "G8"
+ ],
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "cells": 16
+ },
+ "confirmation": {
+ "methods_per_workload": {
+ "mnist_compact": [
+ "G8",
+ "G6"
+ ],
+ "mnist_wide": [
+ "G8",
+ "G5"
+ ],
+ "fashion_compact": [
+ "G8",
+ "G6"
+ ],
+ "fashion_wide": [
+ "G8",
+ "G5"
+ ]
+ },
+ "subset_size": 10000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ]
+ },
+ "selection": {
+ "candidates": [
+ "G0",
+ "G5",
+ "G6"
+ ],
+ "ranking": [
+ "validation_nll_ascending",
+ "validation_accuracy_descending"
+ ],
+ "confirmation_reference": "G8"
+ },
+ "feasibility_contract": {
+ "execution": "all_confirmed_runs_complete_with_finite_metrics",
+ "minimum_validation_nll_reduction_fraction": 0.2,
+ "minimum_validation_accuracy_gain_percentage_points": 20.0,
+ "requires_both_optimization_thresholds": true
+ },
+ "validation": {
+ "source": "official_training_split_only",
+ "split": "50000_search_10000_validation_stratified",
+ "split_seed": 20260902,
+ "official_test_split_used": false
+ }
+ },
+ "method_configs": {
+ "G0": {
+ "config_id": "G0",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "exact V5 control"
+ },
+ "G5": {
+ "config_id": "G5",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test sufficient bound expansion"
+ },
+ "G6": {
+ "config_id": "G6",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 1.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test broader normalized initialization"
+ },
+ "G8": {
+ "config_id": "G8",
+ "scale_type": "optimizer_default",
+ "init_position_mode": "independent",
+ "position_radius": 0.05,
+ "initial_velocity_radius": 0.05,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "retained semantic control (public Optimizer)"
+ }
+ },
+ "workloads": {
+ "mnist_compact": {
+ "workload_id": "mnist_compact",
+ "dataset_name": "mnist",
+ "model_name": "compact_cnn",
+ "parameter_count": 9098,
+ "model_fingerprint": "d0eee0ffd33088ed",
+ "data_fingerprint": "26bd2ed5f27e7d24",
+ "split_fingerprint": "51b289d9f503a9f3",
+ "description": "MNIST dataset with CompactCNN (9,098 params control)"
+ },
+ "mnist_wide": {
+ "workload_id": "mnist_wide",
+ "dataset_name": "mnist",
+ "model_name": "wide_cnn",
+ "parameter_count": 55338,
+ "model_fingerprint": "d474d0ab7cc9f83d",
+ "data_fingerprint": "26bd2ed5f27e7d24",
+ "split_fingerprint": "51b289d9f503a9f3",
+ "description": "MNIST dataset with WideCNN (~55k params larger model axis)"
+ },
+ "fashion_compact": {
+ "workload_id": "fashion_compact",
+ "dataset_name": "fashion_mnist",
+ "model_name": "compact_cnn",
+ "parameter_count": 9098,
+ "model_fingerprint": "d0eee0ffd33088ed",
+ "data_fingerprint": "804ce8cb7d21089f",
+ "split_fingerprint": "9b30a85c7ff86e4a",
+ "description": "FashionMNIST dataset with CompactCNN (harder data axis)"
+ },
+ "fashion_wide": {
+ "workload_id": "fashion_wide",
+ "dataset_name": "fashion_mnist",
+ "model_name": "wide_cnn",
+ "parameter_count": 55338,
+ "model_fingerprint": "d474d0ab7cc9f83d",
+ "data_fingerprint": "804ce8cb7d21089f",
+ "split_fingerprint": "9b30a85c7ff86e4a",
+ "description": "FashionMNIST dataset with WideCNN (harder data + larger model axis)"
+ }
+ },
+ "untrained_baselines": {
+ "mnist_compact": {
+ "val_nll": 2.325095,
+ "val_accuracy": 6.65,
+ "val_brier": 0.904644,
+ "val_ece": 0.060849,
+ "val_margin": 0.0109,
+ "objective_loss": 2.325288,
+ "objective_accuracy": 7.05
+ },
+ "mnist_wide": {
+ "val_nll": 2.32458,
+ "val_accuracy": 9.31,
+ "val_brier": 0.904232,
+ "val_ece": 0.025719,
+ "val_margin": 0.006578,
+ "objective_loss": 2.322588,
+ "objective_accuracy": 9.85
+ },
+ "fashion_compact": {
+ "val_nll": 2.320302,
+ "val_accuracy": 8.08,
+ "val_brier": 0.903272,
+ "val_ece": 0.037873,
+ "val_margin": 0.005784,
+ "objective_loss": 2.317111,
+ "objective_accuracy": 8.65
+ },
+ "fashion_wide": {
+ "val_nll": 2.311222,
+ "val_accuracy": 8.77,
+ "val_brier": 0.901676,
+ "val_ece": 0.029384,
+ "val_margin": 0.004878,
+ "objective_loss": 2.311339,
+ "objective_accuracy": 9.3
+ }
+ },
+ "screen_results": [
+ {
+ "workload_id": "mnist_compact",
+ "method_id": "G0",
+ "dataset_name": "mnist",
+ "model_name": "compact_cnn",
+ "parameter_count": 9098,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 2.014459,
+ "gbest_acc": 34.4,
+ "gbest_val_loss": 2.019988,
+ "gbest_val_acc": 33.32,
+ "val_selected_particle_idx": 1,
+ "val_selected_loss": 2.019988,
+ "val_selected_acc": 33.32,
+ "val_metrics": {
+ "accuracy": 33.32,
+ "nll": 2.019988,
+ "brier": 0.834431,
+ "ece": 0.139305,
+ "margin": 0.049729
+ },
+ "wall_time_sec": 0.9417,
+ "optimization_wall_time_sec": 0.8673,
+ "validation_wall_time_sec": 0.0744,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 1106883.43,
+ "is_finite": true
+ },
+ {
+ "workload_id": "mnist_compact",
+ "method_id": "G5",
+ "dataset_name": "mnist",
+ "model_name": "compact_cnn",
+ "parameter_count": 9098,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.971574,
+ "gbest_acc": 32.35,
+ "gbest_val_loss": 1.959743,
+ "gbest_val_acc": 33.95,
+ "val_selected_particle_idx": 9,
+ "val_selected_loss": 1.959743,
+ "val_selected_acc": 33.95,
+ "val_metrics": {
+ "accuracy": 33.95,
+ "nll": 1.959743,
+ "brier": 0.814657,
+ "ece": 0.092241,
+ "margin": 0.081765
+ },
+ "wall_time_sec": 0.9124,
+ "optimization_wall_time_sec": 0.8425,
+ "validation_wall_time_sec": 0.0699,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 1139465.88,
+ "is_finite": true
+ },
+ {
+ "workload_id": "mnist_compact",
+ "method_id": "G6",
+ "dataset_name": "mnist",
+ "model_name": "compact_cnn",
+ "parameter_count": 9098,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.941859,
+ "gbest_acc": 35.35,
+ "gbest_val_loss": 1.958177,
+ "gbest_val_acc": 35.03,
+ "val_selected_particle_idx": 11,
+ "val_selected_loss": 1.957307,
+ "val_selected_acc": 35.11,
+ "val_metrics": {
+ "accuracy": 35.11,
+ "nll": 1.957307,
+ "brier": 0.80199,
+ "ece": 0.079196,
+ "margin": 0.101943
+ },
+ "wall_time_sec": 0.7827,
+ "optimization_wall_time_sec": 0.7159,
+ "validation_wall_time_sec": 0.0668,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 1340969.41,
+ "is_finite": true
+ },
+ {
+ "workload_id": "mnist_compact",
+ "method_id": "G8",
+ "dataset_name": "mnist",
+ "model_name": "compact_cnn",
+ "parameter_count": 9098,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.675063,
+ "gbest_acc": 43.6,
+ "gbest_val_loss": null,
+ "gbest_val_acc": null,
+ "val_selected_particle_idx": null,
+ "val_selected_loss": 1.690442,
+ "val_selected_acc": 43.88,
+ "val_metrics": {
+ "accuracy": 43.88,
+ "nll": 1.690442,
+ "brier": 0.721828,
+ "ece": 0.046373,
+ "margin": 0.20173
+ },
+ "wall_time_sec": 1.1597,
+ "optimization_wall_time_sec": 0.975,
+ "validation_wall_time_sec": 0.1847,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2219912,
+ "throughput_samples_per_sec": 984615.38,
+ "is_finite": true
+ },
+ {
+ "workload_id": "mnist_wide",
+ "method_id": "G0",
+ "dataset_name": "mnist",
+ "model_name": "wide_cnn",
+ "parameter_count": 55338,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 2.087951,
+ "gbest_acc": 32.45,
+ "gbest_val_loss": 2.088156,
+ "gbest_val_acc": 33.19,
+ "val_selected_particle_idx": 1,
+ "val_selected_loss": 2.088156,
+ "val_selected_acc": 33.19,
+ "val_metrics": {
+ "accuracy": 33.19,
+ "nll": 2.088156,
+ "brier": 0.841868,
+ "ece": 0.149299,
+ "margin": 0.048573
+ },
+ "wall_time_sec": 1.8103,
+ "optimization_wall_time_sec": 1.6122,
+ "validation_wall_time_sec": 0.1981,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 595459.62,
+ "is_finite": true
+ },
+ {
+ "workload_id": "mnist_wide",
+ "method_id": "G5",
+ "dataset_name": "mnist",
+ "model_name": "wide_cnn",
+ "parameter_count": 55338,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.924357,
+ "gbest_acc": 39.5,
+ "gbest_val_loss": 1.913567,
+ "gbest_val_acc": 39.87,
+ "val_selected_particle_idx": 1,
+ "val_selected_loss": 1.913566,
+ "val_selected_acc": 39.87,
+ "val_metrics": {
+ "accuracy": 39.87,
+ "nll": 1.913566,
+ "brier": 0.788297,
+ "ece": 0.114298,
+ "margin": 0.113113
+ },
+ "wall_time_sec": 1.4089,
+ "optimization_wall_time_sec": 1.2427,
+ "validation_wall_time_sec": 0.1662,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 772511.47,
+ "is_finite": true
+ },
+ {
+ "workload_id": "mnist_wide",
+ "method_id": "G6",
+ "dataset_name": "mnist",
+ "model_name": "wide_cnn",
+ "parameter_count": 55338,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 2.014518,
+ "gbest_acc": 27.8,
+ "gbest_val_loss": 2.017511,
+ "gbest_val_acc": 29.46,
+ "val_selected_particle_idx": 2,
+ "val_selected_loss": 2.017511,
+ "val_selected_acc": 29.46,
+ "val_metrics": {
+ "accuracy": 29.46,
+ "nll": 2.017511,
+ "brier": 0.836293,
+ "ece": 0.08699,
+ "margin": 0.050265
+ },
+ "wall_time_sec": 1.4093,
+ "optimization_wall_time_sec": 1.2355,
+ "validation_wall_time_sec": 0.1738,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 777013.35,
+ "is_finite": true
+ },
+ {
+ "workload_id": "mnist_wide",
+ "method_id": "G8",
+ "dataset_name": "mnist",
+ "model_name": "wide_cnn",
+ "parameter_count": 55338,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 2.062368,
+ "gbest_acc": 20.3,
+ "gbest_val_loss": null,
+ "gbest_val_acc": null,
+ "val_selected_particle_idx": null,
+ "val_selected_loss": 2.056341,
+ "val_selected_acc": 20.43,
+ "val_metrics": {
+ "accuracy": 20.43,
+ "nll": 2.056341,
+ "brier": 0.850317,
+ "ece": 0.022169,
+ "margin": 0.052276
+ },
+ "wall_time_sec": 1.3145,
+ "optimization_wall_time_sec": 1.1228,
+ "validation_wall_time_sec": 0.1917,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13502472,
+ "throughput_samples_per_sec": 855005.34,
+ "is_finite": true
+ },
+ {
+ "workload_id": "fashion_compact",
+ "method_id": "G0",
+ "dataset_name": "fashion_mnist",
+ "model_name": "compact_cnn",
+ "parameter_count": 9098,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.96974,
+ "gbest_acc": 28.15,
+ "gbest_val_loss": 1.969548,
+ "gbest_val_acc": 28.25,
+ "val_selected_particle_idx": 0,
+ "val_selected_loss": 1.969548,
+ "val_selected_acc": 28.25,
+ "val_metrics": {
+ "accuracy": 28.25,
+ "nll": 1.969548,
+ "brier": 0.831504,
+ "ece": 0.090757,
+ "margin": 0.055678
+ },
+ "wall_time_sec": 0.8633,
+ "optimization_wall_time_sec": 0.7869,
+ "validation_wall_time_sec": 0.0764,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 1219977.13,
+ "is_finite": true
+ },
+ {
+ "workload_id": "fashion_compact",
+ "method_id": "G5",
+ "dataset_name": "fashion_mnist",
+ "model_name": "compact_cnn",
+ "parameter_count": 9098,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.874629,
+ "gbest_acc": 36.6,
+ "gbest_val_loss": 1.893233,
+ "gbest_val_acc": 35.54,
+ "val_selected_particle_idx": 3,
+ "val_selected_loss": 1.892402,
+ "val_selected_acc": 34.31,
+ "val_metrics": {
+ "accuracy": 34.31,
+ "nll": 1.892402,
+ "brier": 0.798486,
+ "ece": 0.105844,
+ "margin": 0.071749
+ },
+ "wall_time_sec": 0.9283,
+ "optimization_wall_time_sec": 0.8554,
+ "validation_wall_time_sec": 0.073,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 1122281.97,
+ "is_finite": true
+ },
+ {
+ "workload_id": "fashion_compact",
+ "method_id": "G6",
+ "dataset_name": "fashion_mnist",
+ "model_name": "compact_cnn",
+ "parameter_count": 9098,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.844914,
+ "gbest_acc": 33.5,
+ "gbest_val_loss": 1.824273,
+ "gbest_val_acc": 35.2,
+ "val_selected_particle_idx": 8,
+ "val_selected_loss": 1.824273,
+ "val_selected_acc": 35.2,
+ "val_metrics": {
+ "accuracy": 35.2,
+ "nll": 1.824273,
+ "brier": 0.787638,
+ "ece": 0.046928,
+ "margin": 0.169004
+ },
+ "wall_time_sec": 0.9054,
+ "optimization_wall_time_sec": 0.8331,
+ "validation_wall_time_sec": 0.0723,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 1152322.65,
+ "is_finite": true
+ },
+ {
+ "workload_id": "fashion_compact",
+ "method_id": "G8",
+ "dataset_name": "fashion_mnist",
+ "model_name": "compact_cnn",
+ "parameter_count": 9098,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.895269,
+ "gbest_acc": 28.85,
+ "gbest_val_loss": null,
+ "gbest_val_acc": null,
+ "val_selected_particle_idx": null,
+ "val_selected_loss": 1.88018,
+ "val_selected_acc": 30.85,
+ "val_metrics": {
+ "accuracy": 30.85,
+ "nll": 1.88018,
+ "brier": 0.800592,
+ "ece": 0.043279,
+ "margin": 0.16498
+ },
+ "wall_time_sec": 1.0335,
+ "optimization_wall_time_sec": 0.8046,
+ "validation_wall_time_sec": 0.2289,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2219912,
+ "throughput_samples_per_sec": 1193139.45,
+ "is_finite": true
+ },
+ {
+ "workload_id": "fashion_wide",
+ "method_id": "G0",
+ "dataset_name": "fashion_mnist",
+ "model_name": "wide_cnn",
+ "parameter_count": 55338,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.98436,
+ "gbest_acc": 36.05,
+ "gbest_val_loss": 1.981317,
+ "gbest_val_acc": 36.39,
+ "val_selected_particle_idx": 8,
+ "val_selected_loss": 1.981316,
+ "val_selected_acc": 36.39,
+ "val_metrics": {
+ "accuracy": 36.39,
+ "nll": 1.981316,
+ "brier": 0.826711,
+ "ece": 0.180482,
+ "margin": 0.042564
+ },
+ "wall_time_sec": 1.9694,
+ "optimization_wall_time_sec": 1.7767,
+ "validation_wall_time_sec": 0.1927,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 540327.57,
+ "is_finite": true
+ },
+ {
+ "workload_id": "fashion_wide",
+ "method_id": "G5",
+ "dataset_name": "fashion_mnist",
+ "model_name": "wide_cnn",
+ "parameter_count": 55338,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.938569,
+ "gbest_acc": 33.3,
+ "gbest_val_loss": 1.945862,
+ "gbest_val_acc": 31.97,
+ "val_selected_particle_idx": 0,
+ "val_selected_loss": 1.945862,
+ "val_selected_acc": 31.97,
+ "val_metrics": {
+ "accuracy": 31.97,
+ "nll": 1.945862,
+ "brier": 0.818283,
+ "ece": 0.114404,
+ "margin": 0.049718
+ },
+ "wall_time_sec": 1.335,
+ "optimization_wall_time_sec": 1.189,
+ "validation_wall_time_sec": 0.146,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 807401.18,
+ "is_finite": true
+ },
+ {
+ "workload_id": "fashion_wide",
+ "method_id": "G6",
+ "dataset_name": "fashion_mnist",
+ "model_name": "wide_cnn",
+ "parameter_count": 55338,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.960139,
+ "gbest_acc": 28.1,
+ "gbest_val_loss": 1.975825,
+ "gbest_val_acc": 28.64,
+ "val_selected_particle_idx": 10,
+ "val_selected_loss": 1.975825,
+ "val_selected_acc": 28.64,
+ "val_metrics": {
+ "accuracy": 28.64,
+ "nll": 1.975825,
+ "brier": 0.825556,
+ "ece": 0.038186,
+ "margin": 0.084988
+ },
+ "wall_time_sec": 1.4862,
+ "optimization_wall_time_sec": 1.3055,
+ "validation_wall_time_sec": 0.1807,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 17,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 735350.44,
+ "is_finite": true
+ },
+ {
+ "workload_id": "fashion_wide",
+ "method_id": "G8",
+ "dataset_name": "fashion_mnist",
+ "model_name": "wide_cnn",
+ "parameter_count": 55338,
+ "subset_size": 2000,
+ "particles": 12,
+ "epochs": 40,
+ "seed": 91,
+ "gbest_loss": 1.976977,
+ "gbest_acc": 28.45,
+ "gbest_val_loss": null,
+ "gbest_val_acc": null,
+ "val_selected_particle_idx": null,
+ "val_selected_loss": 1.987923,
+ "val_selected_acc": 28.69,
+ "val_metrics": {
+ "accuracy": 28.69,
+ "nll": 1.987923,
+ "brier": 0.829408,
+ "ece": 0.053144,
+ "margin": 0.069324
+ },
+ "wall_time_sec": 1.2958,
+ "optimization_wall_time_sec": 1.1088,
+ "validation_wall_time_sec": 0.187,
+ "total_queries": 480,
+ "total_sample_evaluations": 960000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13502472,
+ "throughput_samples_per_sec": 865800.87,
+ "is_finite": true
+ }
+ ],
+ "normalized_method_selections": {
+ "mnist_compact": "G6",
+ "mnist_wide": "G5",
+ "fashion_compact": "G6",
+ "fashion_wide": "G5"
+ },
+ "confirmation_results": {
+ "mnist_compact": {
+ "G8": {
+ "workload_id": "mnist_compact",
+ "method_id": "G8",
+ "subset_size": 10000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ],
+ "stats": {
+ "val_acc": {
+ "mean": 49.153333,
+ "std": 1.320656,
+ "median": 48.96,
+ "iqr": 1.31,
+ "ci95_t": 3.280728
+ },
+ "val_nll": {
+ "mean": 1.518089,
+ "std": 0.061523,
+ "median": 1.512633,
+ "iqr": 0.061342,
+ "ci95_t": 0.152834
+ },
+ "val_brier": {
+ "mean": 0.663921,
+ "std": 0.024244,
+ "median": 0.659644,
+ "iqr": 0.02396,
+ "ci95_t": 0.060226
+ },
+ "val_ece": {
+ "mean": 0.066236,
+ "std": 0.050095,
+ "median": 0.060988,
+ "iqr": 0.049888,
+ "ci95_t": 0.124443
+ },
+ "gbest_loss": {
+ "mean": 1.518602,
+ "std": 0.062467,
+ "median": 1.509299,
+ "iqr": 0.061945,
+ "ci95_t": 0.155179
+ },
+ "gbest_acc": {
+ "mean": 48.96,
+ "std": 1.407551,
+ "median": 49.28,
+ "iqr": 1.38,
+ "ci95_t": 3.496589
+ },
+ "wall_time_sec": {
+ "mean": 4.530167,
+ "std": 0.073436,
+ "median": 4.5186,
+ "iqr": 0.07275,
+ "ci95_t": 0.182428
+ },
+ "optimization_wall_time_sec": {
+ "mean": 4.3879,
+ "std": 0.064886,
+ "median": 4.3684,
+ "iqr": 0.06265,
+ "ci95_t": 0.161188
+ },
+ "throughput_samples_per_sec": {
+ "mean": 2188151.803333,
+ "std": 32164.042335,
+ "median": 2197600.95,
+ "iqr": 31105.64,
+ "ci95_t": 79900.788332
+ }
+ },
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "val_selected_loss": 1.459476,
+ "val_selected_acc": 50.56,
+ "val_metrics": {
+ "accuracy": 50.56,
+ "nll": 1.459476,
+ "brier": 0.6421,
+ "ece": 0.018972,
+ "margin": 0.29628
+ },
+ "gbest_loss": 1.461308,
+ "gbest_acc": 50.18,
+ "wall_time_sec": 4.5186,
+ "optimization_wall_time_sec": 4.3684,
+ "validation_wall_time_sec": 0.1502,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2219912,
+ "throughput_samples_per_sec": 2197600.95
+ },
+ {
+ "seed": 102,
+ "val_selected_loss": 1.582159,
+ "val_selected_acc": 47.94,
+ "val_metrics": {
+ "accuracy": 47.94,
+ "nll": 1.582159,
+ "brier": 0.690019,
+ "ece": 0.118748,
+ "margin": 0.178296
+ },
+ "gbest_loss": 1.585199,
+ "gbest_acc": 47.42,
+ "wall_time_sec": 4.4632,
+ "optimization_wall_time_sec": 4.335,
+ "validation_wall_time_sec": 0.1282,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2219912,
+ "throughput_samples_per_sec": 2214532.87
+ },
+ {
+ "seed": 103,
+ "val_selected_loss": 1.512633,
+ "val_selected_acc": 48.96,
+ "val_metrics": {
+ "accuracy": 48.96,
+ "nll": 1.512633,
+ "brier": 0.659644,
+ "ece": 0.060988,
+ "margin": 0.242224
+ },
+ "gbest_loss": 1.509299,
+ "gbest_acc": 49.28,
+ "wall_time_sec": 4.6087,
+ "optimization_wall_time_sec": 4.4603,
+ "validation_wall_time_sec": 0.1484,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2219912,
+ "throughput_samples_per_sec": 2152321.59
+ }
+ ]
+ },
+ "G6": {
+ "workload_id": "mnist_compact",
+ "method_id": "G6",
+ "subset_size": 10000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ],
+ "stats": {
+ "val_acc": {
+ "mean": 45.966667,
+ "std": 3.545438,
+ "median": 46.62,
+ "iqr": 3.5,
+ "ci95_t": 8.807454
+ },
+ "val_nll": {
+ "mean": 1.642081,
+ "std": 0.091398,
+ "median": 1.610062,
+ "iqr": 0.08709,
+ "ci95_t": 0.227048
+ },
+ "val_brier": {
+ "mean": 0.704608,
+ "std": 0.0315,
+ "median": 0.68996,
+ "iqr": 0.028833,
+ "ci95_t": 0.07825
+ },
+ "val_ece": {
+ "mean": 0.115422,
+ "std": 0.039961,
+ "median": 0.116838,
+ "iqr": 0.039942,
+ "ci95_t": 0.09927
+ },
+ "gbest_loss": {
+ "mean": 1.641447,
+ "std": 0.089036,
+ "median": 1.60673,
+ "iqr": 0.083806,
+ "ci95_t": 0.22118
+ },
+ "gbest_acc": {
+ "mean": 46.056667,
+ "std": 3.536444,
+ "median": 46.45,
+ "iqr": 3.52,
+ "ci95_t": 8.785109
+ },
+ "wall_time_sec": {
+ "mean": 5.2706,
+ "std": 1.015911,
+ "median": 4.8932,
+ "iqr": 0.9619,
+ "ci95_t": 2.52369
+ },
+ "optimization_wall_time_sec": {
+ "mean": 5.159533,
+ "std": 0.984816,
+ "median": 4.7957,
+ "iqr": 0.93305,
+ "ci95_t": 2.446446
+ },
+ "throughput_samples_per_sec": {
+ "mean": 1903152.163333,
+ "std": 334907.322507,
+ "median": 2001793.27,
+ "iqr": 323829.22,
+ "ci95_t": 831965.049903
+ }
+ },
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "val_selected_loss": 1.745181,
+ "val_selected_acc": 42.14,
+ "val_metrics": {
+ "accuracy": 42.14,
+ "nll": 1.745181,
+ "brier": 0.740764,
+ "ece": 0.116838,
+ "margin": 0.131853
+ },
+ "gbest_loss": 1.742612,
+ "gbest_acc": 42.34,
+ "wall_time_sec": 4.8932,
+ "optimization_wall_time_sec": 4.7957,
+ "validation_wall_time_sec": 0.0975,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 2001793.27
+ },
+ {
+ "seed": 102,
+ "val_selected_loss": 1.610062,
+ "val_selected_acc": 49.14,
+ "val_metrics": {
+ "accuracy": 49.14,
+ "nll": 1.610062,
+ "brier": 0.68996,
+ "ece": 0.154657,
+ "margin": 0.160339
+ },
+ "gbest_loss": 1.60673,
+ "gbest_acc": 49.38,
+ "wall_time_sec": 6.4212,
+ "optimization_wall_time_sec": 6.2745,
+ "validation_wall_time_sec": 0.1467,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 1530002.39
+ },
+ {
+ "seed": 103,
+ "val_selected_loss": 1.571001,
+ "val_selected_acc": 46.62,
+ "val_metrics": {
+ "accuracy": 46.62,
+ "nll": 1.571001,
+ "brier": 0.683099,
+ "ece": 0.074772,
+ "margin": 0.208291
+ },
+ "gbest_loss": 1.575,
+ "gbest_acc": 46.45,
+ "wall_time_sec": 4.4974,
+ "optimization_wall_time_sec": 4.4084,
+ "validation_wall_time_sec": 0.089,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 2177660.83
+ }
+ ]
+ }
+ },
+ "mnist_wide": {
+ "G8": {
+ "workload_id": "mnist_wide",
+ "method_id": "G8",
+ "subset_size": 10000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ],
+ "stats": {
+ "val_acc": {
+ "mean": 41.03,
+ "std": 4.055083,
+ "median": 41.36,
+ "iqr": 4.045,
+ "ci95_t": 10.073496
+ },
+ "val_nll": {
+ "mean": 1.733351,
+ "std": 0.084331,
+ "median": 1.733455,
+ "iqr": 0.08433,
+ "ci95_t": 0.209491
+ },
+ "val_brier": {
+ "mean": 0.739941,
+ "std": 0.029512,
+ "median": 0.734463,
+ "iqr": 0.029129,
+ "ci95_t": 0.073314
+ },
+ "val_ece": {
+ "mean": 0.088906,
+ "std": 0.015336,
+ "median": 0.083434,
+ "iqr": 0.014586,
+ "ci95_t": 0.038097
+ },
+ "gbest_loss": {
+ "mean": 1.732307,
+ "std": 0.09299,
+ "median": 1.720824,
+ "iqr": 0.092456,
+ "ci95_t": 0.231002
+ },
+ "gbest_acc": {
+ "mean": 40.866667,
+ "std": 3.390197,
+ "median": 40.44,
+ "iqr": 3.37,
+ "ci95_t": 8.421808
+ },
+ "wall_time_sec": {
+ "mean": 9.4569,
+ "std": 0.542029,
+ "median": 9.5612,
+ "iqr": 0.53445,
+ "ci95_t": 1.34649
+ },
+ "optimization_wall_time_sec": {
+ "mean": 9.2436,
+ "std": 0.534734,
+ "median": 9.3462,
+ "iqr": 0.5273,
+ "ci95_t": 1.328367
+ },
+ "throughput_samples_per_sec": {
+ "mean": 1040918.586667,
+ "std": 61275.63655,
+ "median": 1027155.42,
+ "iqr": 60105.2,
+ "ci95_t": 152218.791868
+ }
+ },
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "val_selected_loss": 1.733455,
+ "val_selected_acc": 41.36,
+ "val_metrics": {
+ "accuracy": 41.36,
+ "nll": 1.733455,
+ "brier": 0.734463,
+ "ece": 0.077057,
+ "margin": 0.152205
+ },
+ "gbest_loss": 1.720824,
+ "gbest_acc": 40.44,
+ "wall_time_sec": 8.8703,
+ "optimization_wall_time_sec": 8.665,
+ "validation_wall_time_sec": 0.2053,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13502472,
+ "throughput_samples_per_sec": 1107905.37
+ },
+ {
+ "seed": 102,
+ "val_selected_loss": 1.648968,
+ "val_selected_acc": 44.91,
+ "val_metrics": {
+ "accuracy": 44.91,
+ "nll": 1.648968,
+ "brier": 0.713552,
+ "ece": 0.106228,
+ "margin": 0.14736
+ },
+ "gbest_loss": 1.645592,
+ "gbest_acc": 44.45,
+ "wall_time_sec": 9.5612,
+ "optimization_wall_time_sec": 9.3462,
+ "validation_wall_time_sec": 0.215,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13502472,
+ "throughput_samples_per_sec": 1027155.42
+ },
+ {
+ "seed": 103,
+ "val_selected_loss": 1.817629,
+ "val_selected_acc": 36.82,
+ "val_metrics": {
+ "accuracy": 36.82,
+ "nll": 1.817629,
+ "brier": 0.771809,
+ "ece": 0.083434,
+ "margin": 0.112362
+ },
+ "gbest_loss": 1.830505,
+ "gbest_acc": 37.71,
+ "wall_time_sec": 9.9392,
+ "optimization_wall_time_sec": 9.7196,
+ "validation_wall_time_sec": 0.2196,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13502472,
+ "throughput_samples_per_sec": 987694.97
+ }
+ ]
+ },
+ "G5": {
+ "workload_id": "mnist_wide",
+ "method_id": "G5",
+ "subset_size": 10000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ],
+ "stats": {
+ "val_acc": {
+ "mean": 43.86,
+ "std": 3.512222,
+ "median": 43.1,
+ "iqr": 3.45,
+ "ci95_t": 8.724938
+ },
+ "val_nll": {
+ "mean": 1.721259,
+ "std": 0.098656,
+ "median": 1.66647,
+ "iqr": 0.086496,
+ "ci95_t": 0.245077
+ },
+ "val_brier": {
+ "mean": 0.734178,
+ "std": 0.034098,
+ "median": 0.737217,
+ "iqr": 0.033996,
+ "ci95_t": 0.084704
+ },
+ "val_ece": {
+ "mean": 0.150847,
+ "std": 0.013927,
+ "median": 0.144481,
+ "iqr": 0.012789,
+ "ci95_t": 0.034596
+ },
+ "gbest_loss": {
+ "mean": 1.716147,
+ "std": 0.098467,
+ "median": 1.667192,
+ "iqr": 0.088872,
+ "ci95_t": 0.244608
+ },
+ "gbest_acc": {
+ "mean": 44.03,
+ "std": 4.013776,
+ "median": 43.43,
+ "iqr": 3.98,
+ "ci95_t": 9.970883
+ },
+ "wall_time_sec": {
+ "mean": 9.868467,
+ "std": 0.070779,
+ "median": 9.8397,
+ "iqr": 0.06625,
+ "ci95_t": 0.175827
+ },
+ "optimization_wall_time_sec": {
+ "mean": 9.6602,
+ "std": 0.069128,
+ "median": 9.6324,
+ "iqr": 0.0648,
+ "ci95_t": 0.171725
+ },
+ "throughput_samples_per_sec": {
+ "mean": 993802.05,
+ "std": 7086.000756,
+ "median": 996636.35,
+ "iqr": 6647.29,
+ "ci95_t": 17602.795091
+ }
+ },
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "val_selected_loss": 1.66647,
+ "val_selected_acc": 43.1,
+ "val_metrics": {
+ "accuracy": 43.1,
+ "nll": 1.66647,
+ "brier": 0.737217,
+ "ece": 0.144481,
+ "margin": 0.102556
+ },
+ "gbest_loss": 1.667192,
+ "gbest_acc": 43.43,
+ "wall_time_sec": 9.9491,
+ "optimization_wall_time_sec": 9.7389,
+ "validation_wall_time_sec": 0.2102,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 985737.61
+ },
+ {
+ "seed": 102,
+ "val_selected_loss": 1.662158,
+ "val_selected_acc": 47.69,
+ "val_metrics": {
+ "accuracy": 47.69,
+ "nll": 1.662158,
+ "brier": 0.698663,
+ "ece": 0.166819,
+ "margin": 0.156783
+ },
+ "gbest_loss": 1.651753,
+ "gbest_acc": 48.31,
+ "wall_time_sec": 9.8166,
+ "optimization_wall_time_sec": 9.6093,
+ "validation_wall_time_sec": 0.2073,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 999032.19
+ },
+ {
+ "seed": 103,
+ "val_selected_loss": 1.83515,
+ "val_selected_acc": 40.79,
+ "val_metrics": {
+ "accuracy": 40.79,
+ "nll": 1.83515,
+ "brier": 0.766655,
+ "ece": 0.141241,
+ "margin": 0.108132
+ },
+ "gbest_loss": 1.829497,
+ "gbest_acc": 40.35,
+ "wall_time_sec": 9.8397,
+ "optimization_wall_time_sec": 9.6324,
+ "validation_wall_time_sec": 0.2073,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 996636.35
+ }
+ ]
+ }
+ },
+ "fashion_compact": {
+ "G8": {
+ "workload_id": "fashion_compact",
+ "method_id": "G8",
+ "subset_size": 10000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ],
+ "stats": {
+ "val_acc": {
+ "mean": 47.003333,
+ "std": 5.2259,
+ "median": 44.5,
+ "iqr": 4.755,
+ "ci95_t": 12.981998
+ },
+ "val_nll": {
+ "mean": 1.511217,
+ "std": 0.168628,
+ "median": 1.593665,
+ "iqr": 0.152765,
+ "ci95_t": 0.4189
+ },
+ "val_brier": {
+ "mean": 0.670829,
+ "std": 0.047121,
+ "median": 0.69484,
+ "iqr": 0.042284,
+ "ci95_t": 0.117055
+ },
+ "val_ece": {
+ "mean": 0.051117,
+ "std": 0.028629,
+ "median": 0.042956,
+ "iqr": 0.027743,
+ "ci95_t": 0.071118
+ },
+ "gbest_loss": {
+ "mean": 1.505129,
+ "std": 0.173608,
+ "median": 1.585615,
+ "iqr": 0.159001,
+ "ci95_t": 0.431271
+ },
+ "gbest_acc": {
+ "mean": 47.446667,
+ "std": 5.162212,
+ "median": 44.87,
+ "iqr": 4.655,
+ "ci95_t": 12.823787
+ },
+ "wall_time_sec": {
+ "mean": 5.0146,
+ "std": 0.07329,
+ "median": 4.9742,
+ "iqr": 0.0644,
+ "ci95_t": 0.182065
+ },
+ "optimization_wall_time_sec": {
+ "mean": 4.860267,
+ "std": 0.074059,
+ "median": 4.8208,
+ "iqr": 0.0657,
+ "ci95_t": 0.183974
+ },
+ "throughput_samples_per_sec": {
+ "mean": 1975503.406667,
+ "std": 29841.726913,
+ "median": 1991370.73,
+ "iqr": 26489.615,
+ "ci95_t": 74131.773634
+ }
+ },
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "val_selected_loss": 1.317228,
+ "val_selected_acc": 53.01,
+ "val_metrics": {
+ "accuracy": 53.01,
+ "nll": 1.317228,
+ "brier": 0.616539,
+ "ece": 0.042956,
+ "margin": 0.295591
+ },
+ "gbest_loss": 1.305885,
+ "gbest_acc": 53.39,
+ "wall_time_sec": 4.9704,
+ "optimization_wall_time_sec": 4.8143,
+ "validation_wall_time_sec": 0.1561,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2219912,
+ "throughput_samples_per_sec": 1994059.36
+ },
+ {
+ "seed": 102,
+ "val_selected_loss": 1.593665,
+ "val_selected_acc": 43.5,
+ "val_metrics": {
+ "accuracy": 43.5,
+ "nll": 1.593665,
+ "brier": 0.69484,
+ "ece": 0.027455,
+ "margin": 0.271024
+ },
+ "gbest_loss": 1.585615,
+ "gbest_acc": 44.08,
+ "wall_time_sec": 5.0992,
+ "optimization_wall_time_sec": 4.9457,
+ "validation_wall_time_sec": 0.1534,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2219912,
+ "throughput_samples_per_sec": 1941080.13
+ },
+ {
+ "seed": 103,
+ "val_selected_loss": 1.622758,
+ "val_selected_acc": 44.5,
+ "val_metrics": {
+ "accuracy": 44.5,
+ "nll": 1.622758,
+ "brier": 0.701107,
+ "ece": 0.08294,
+ "margin": 0.177938
+ },
+ "gbest_loss": 1.623887,
+ "gbest_acc": 44.87,
+ "wall_time_sec": 4.9742,
+ "optimization_wall_time_sec": 4.8208,
+ "validation_wall_time_sec": 0.1534,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2219912,
+ "throughput_samples_per_sec": 1991370.73
+ }
+ ]
+ },
+ "G6": {
+ "workload_id": "fashion_compact",
+ "method_id": "G6",
+ "subset_size": 10000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ],
+ "stats": {
+ "val_acc": {
+ "mean": 45.616667,
+ "std": 3.585392,
+ "median": 44.86,
+ "iqr": 3.525,
+ "ci95_t": 8.906704
+ },
+ "val_nll": {
+ "mean": 1.584443,
+ "std": 0.053077,
+ "median": 1.593562,
+ "iqr": 0.052487,
+ "ci95_t": 0.131853
+ },
+ "val_brier": {
+ "mean": 0.699684,
+ "std": 0.023018,
+ "median": 0.699068,
+ "iqr": 0.023011,
+ "ci95_t": 0.05718
+ },
+ "val_ece": {
+ "mean": 0.098265,
+ "std": 0.040761,
+ "median": 0.075459,
+ "iqr": 0.035656,
+ "ci95_t": 0.101256
+ },
+ "gbest_loss": {
+ "mean": 1.577682,
+ "std": 0.060531,
+ "median": 1.589026,
+ "iqr": 0.059728,
+ "ci95_t": 0.150369
+ },
+ "gbest_acc": {
+ "mean": 45.83,
+ "std": 3.77342,
+ "median": 44.62,
+ "iqr": 3.625,
+ "ci95_t": 9.373798
+ },
+ "wall_time_sec": {
+ "mean": 4.839267,
+ "std": 0.025908,
+ "median": 4.8501,
+ "iqr": 0.02415,
+ "ci95_t": 0.064361
+ },
+ "optimization_wall_time_sec": {
+ "mean": 4.7373,
+ "std": 0.0259,
+ "median": 4.7484,
+ "iqr": 0.02405,
+ "ci95_t": 0.06434
+ },
+ "throughput_samples_per_sec": {
+ "mean": 2026511.273333,
+ "std": 11111.347421,
+ "median": 2021733.64,
+ "iqr": 10312.26,
+ "ci95_t": 27602.420402
+ }
+ },
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "val_selected_loss": 1.593562,
+ "val_selected_acc": 44.86,
+ "val_metrics": {
+ "accuracy": 44.86,
+ "nll": 1.593562,
+ "brier": 0.699068,
+ "ece": 0.075459,
+ "margin": 0.179908
+ },
+ "gbest_loss": 1.589026,
+ "gbest_acc": 44.62,
+ "wall_time_sec": 4.8501,
+ "optimization_wall_time_sec": 4.7484,
+ "validation_wall_time_sec": 0.1017,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 2021733.64
+ },
+ {
+ "seed": 102,
+ "val_selected_loss": 1.63237,
+ "val_selected_acc": 42.47,
+ "val_metrics": {
+ "accuracy": 42.47,
+ "nll": 1.63237,
+ "brier": 0.723003,
+ "ece": 0.074012,
+ "margin": 0.176538
+ },
+ "gbest_loss": 1.631738,
+ "gbest_acc": 42.81,
+ "wall_time_sec": 4.8097,
+ "optimization_wall_time_sec": 4.7077,
+ "validation_wall_time_sec": 0.102,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 2039212.35
+ },
+ {
+ "seed": 103,
+ "val_selected_loss": 1.527397,
+ "val_selected_acc": 49.52,
+ "val_metrics": {
+ "accuracy": 49.52,
+ "nll": 1.527397,
+ "brier": 0.67698,
+ "ece": 0.145324,
+ "margin": 0.156547
+ },
+ "gbest_loss": 1.512281,
+ "gbest_acc": 50.06,
+ "wall_time_sec": 4.858,
+ "optimization_wall_time_sec": 4.7558,
+ "validation_wall_time_sec": 0.1022,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 2183520,
+ "throughput_samples_per_sec": 2018587.83
+ }
+ ]
+ }
+ },
+ "fashion_wide": {
+ "G8": {
+ "workload_id": "fashion_wide",
+ "method_id": "G8",
+ "subset_size": 10000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ],
+ "stats": {
+ "val_acc": {
+ "mean": 41.666667,
+ "std": 2.269016,
+ "median": 40.94,
+ "iqr": 2.18,
+ "ci95_t": 5.63661
+ },
+ "val_nll": {
+ "mean": 1.615937,
+ "std": 0.036692,
+ "median": 1.617185,
+ "iqr": 0.036676,
+ "ci95_t": 0.091149
+ },
+ "val_brier": {
+ "mean": 0.716583,
+ "std": 0.015392,
+ "median": 0.719193,
+ "iqr": 0.015226,
+ "ci95_t": 0.038237
+ },
+ "val_ece": {
+ "mean": 0.039104,
+ "std": 0.003431,
+ "median": 0.039736,
+ "iqr": 0.003387,
+ "ci95_t": 0.008523
+ },
+ "gbest_loss": {
+ "mean": 1.612987,
+ "std": 0.031992,
+ "median": 1.612069,
+ "iqr": 0.031983,
+ "ci95_t": 0.079474
+ },
+ "gbest_acc": {
+ "mean": 41.346667,
+ "std": 2.309899,
+ "median": 40.59,
+ "iqr": 2.215,
+ "ci95_t": 5.73817
+ },
+ "wall_time_sec": {
+ "mean": 9.499333,
+ "std": 0.068809,
+ "median": 9.5038,
+ "iqr": 0.0687,
+ "ci95_t": 0.170932
+ },
+ "optimization_wall_time_sec": {
+ "mean": 9.280267,
+ "std": 0.067396,
+ "median": 9.2862,
+ "iqr": 0.0672,
+ "ci95_t": 0.167423
+ },
+ "throughput_samples_per_sec": {
+ "mean": 1034489.443333,
+ "std": 7520.124937,
+ "median": 1033792.08,
+ "iqr": 7495.835,
+ "ci95_t": 18681.231187
+ }
+ },
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "val_selected_loss": 1.617185,
+ "val_selected_acc": 40.94,
+ "val_metrics": {
+ "accuracy": 40.94,
+ "nll": 1.617185,
+ "brier": 0.719193,
+ "ece": 0.039736,
+ "margin": 0.182429
+ },
+ "gbest_loss": 1.612069,
+ "gbest_acc": 40.59,
+ "wall_time_sec": 9.4284,
+ "optimization_wall_time_sec": 9.2101,
+ "validation_wall_time_sec": 0.2183,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13502472,
+ "throughput_samples_per_sec": 1042333.96
+ },
+ {
+ "seed": 102,
+ "val_selected_loss": 1.651989,
+ "val_selected_acc": 39.85,
+ "val_metrics": {
+ "accuracy": 39.85,
+ "nll": 1.651989,
+ "brier": 0.730504,
+ "ece": 0.035401,
+ "margin": 0.165291
+ },
+ "gbest_loss": 1.645429,
+ "gbest_acc": 39.51,
+ "wall_time_sec": 9.5038,
+ "optimization_wall_time_sec": 9.2862,
+ "validation_wall_time_sec": 0.2176,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13502472,
+ "throughput_samples_per_sec": 1033792.08
+ },
+ {
+ "seed": 103,
+ "val_selected_loss": 1.578637,
+ "val_selected_acc": 44.21,
+ "val_metrics": {
+ "accuracy": 44.21,
+ "nll": 1.578637,
+ "brier": 0.700053,
+ "ece": 0.042175,
+ "margin": 0.190905
+ },
+ "gbest_loss": 1.581464,
+ "gbest_acc": 43.94,
+ "wall_time_sec": 9.5658,
+ "optimization_wall_time_sec": 9.3445,
+ "validation_wall_time_sec": 0.2213,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 13,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13502472,
+ "throughput_samples_per_sec": 1027342.29
+ }
+ ]
+ },
+ "G5": {
+ "workload_id": "fashion_wide",
+ "method_id": "G5",
+ "subset_size": 10000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ],
+ "stats": {
+ "val_acc": {
+ "mean": 46.31,
+ "std": 7.568494,
+ "median": 48.76,
+ "iqr": 7.265,
+ "ci95_t": 18.801388
+ },
+ "val_nll": {
+ "mean": 1.525747,
+ "std": 0.149706,
+ "median": 1.459695,
+ "iqr": 0.138346,
+ "ci95_t": 0.371893
+ },
+ "val_brier": {
+ "mean": 0.695206,
+ "std": 0.057206,
+ "median": 0.675207,
+ "iqr": 0.054522,
+ "ci95_t": 0.14211
+ },
+ "val_ece": {
+ "mean": 0.135458,
+ "std": 0.015271,
+ "median": 0.132617,
+ "iqr": 0.015072,
+ "ci95_t": 0.037936
+ },
+ "gbest_loss": {
+ "mean": 1.524557,
+ "std": 0.150724,
+ "median": 1.462688,
+ "iqr": 0.14088,
+ "ci95_t": 0.374424
+ },
+ "gbest_acc": {
+ "mean": 46.256667,
+ "std": 8.185019,
+ "median": 49.01,
+ "iqr": 7.83,
+ "ci95_t": 20.332937
+ },
+ "wall_time_sec": {
+ "mean": 10.038833,
+ "std": 0.159562,
+ "median": 10.0574,
+ "iqr": 0.15875,
+ "ci95_t": 0.396379
+ },
+ "optimization_wall_time_sec": {
+ "mean": 9.8224,
+ "std": 0.154476,
+ "median": 9.8419,
+ "iqr": 0.15355,
+ "ci95_t": 0.383744
+ },
+ "throughput_samples_per_sec": {
+ "mean": 977519.543333,
+ "std": 15420.239061,
+ "median": 975421.41,
+ "iqr": 15312.81,
+ "ci95_t": 38306.418218
+ }
+ },
+ "per_seed_runs": [
+ {
+ "seed": 101,
+ "val_selected_loss": 1.420427,
+ "val_selected_acc": 52.35,
+ "val_metrics": {
+ "accuracy": 52.35,
+ "nll": 1.420427,
+ "brier": 0.650684,
+ "ece": 0.15195,
+ "margin": 0.168393
+ },
+ "gbest_loss": 1.414612,
+ "gbest_acc": 52.71,
+ "wall_time_sec": 9.8708,
+ "optimization_wall_time_sec": 9.6591,
+ "validation_wall_time_sec": 0.2117,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 993881.42
+ },
+ {
+ "seed": 102,
+ "val_selected_loss": 1.459695,
+ "val_selected_acc": 48.76,
+ "val_metrics": {
+ "accuracy": 48.76,
+ "nll": 1.459695,
+ "brier": 0.675207,
+ "ece": 0.132617,
+ "margin": 0.141615
+ },
+ "gbest_loss": 1.462688,
+ "gbest_acc": 49.01,
+ "wall_time_sec": 10.0574,
+ "optimization_wall_time_sec": 9.8419,
+ "validation_wall_time_sec": 0.2155,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 975421.41
+ },
+ {
+ "seed": 103,
+ "val_selected_loss": 1.697119,
+ "val_selected_acc": 37.82,
+ "val_metrics": {
+ "accuracy": 37.82,
+ "nll": 1.697119,
+ "brier": 0.759727,
+ "ece": 0.121807,
+ "margin": 0.068249
+ },
+ "gbest_loss": 1.696371,
+ "gbest_acc": 37.05,
+ "wall_time_sec": 10.1883,
+ "optimization_wall_time_sec": 9.9662,
+ "validation_wall_time_sec": 0.2221,
+ "total_queries": 960,
+ "total_sample_evaluations": 9600000,
+ "validation_evaluations": 21,
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": 13281120,
+ "throughput_samples_per_sec": 963255.8
+ }
+ ]
+ }
+ }
+ },
+ "feasibility_evaluations": {
+ "mnist_compact": {
+ "G8": {
+ "execution_feasible": true,
+ "optimization_feasible": true,
+ "baseline_val_nll": 2.325095,
+ "target_val_nll_threshold": 1.860076,
+ "baseline_val_acc": 6.65,
+ "target_val_acc_threshold": 26.65,
+ "mean_val_nll": 1.518089,
+ "mean_val_acc": 49.1533
+ },
+ "G6": {
+ "execution_feasible": true,
+ "optimization_feasible": true,
+ "baseline_val_nll": 2.325095,
+ "target_val_nll_threshold": 1.860076,
+ "baseline_val_acc": 6.65,
+ "target_val_acc_threshold": 26.65,
+ "mean_val_nll": 1.642081,
+ "mean_val_acc": 45.9667
+ }
+ },
+ "mnist_wide": {
+ "G8": {
+ "execution_feasible": true,
+ "optimization_feasible": true,
+ "baseline_val_nll": 2.32458,
+ "target_val_nll_threshold": 1.859664,
+ "baseline_val_acc": 9.31,
+ "target_val_acc_threshold": 29.31,
+ "mean_val_nll": 1.733351,
+ "mean_val_acc": 41.03
+ },
+ "G5": {
+ "execution_feasible": true,
+ "optimization_feasible": true,
+ "baseline_val_nll": 2.32458,
+ "target_val_nll_threshold": 1.859664,
+ "baseline_val_acc": 9.31,
+ "target_val_acc_threshold": 29.31,
+ "mean_val_nll": 1.721259,
+ "mean_val_acc": 43.86
+ }
+ },
+ "fashion_compact": {
+ "G8": {
+ "execution_feasible": true,
+ "optimization_feasible": true,
+ "baseline_val_nll": 2.320302,
+ "target_val_nll_threshold": 1.856242,
+ "baseline_val_acc": 8.08,
+ "target_val_acc_threshold": 28.08,
+ "mean_val_nll": 1.511217,
+ "mean_val_acc": 47.0033
+ },
+ "G6": {
+ "execution_feasible": true,
+ "optimization_feasible": true,
+ "baseline_val_nll": 2.320302,
+ "target_val_nll_threshold": 1.856242,
+ "baseline_val_acc": 8.08,
+ "target_val_acc_threshold": 28.08,
+ "mean_val_nll": 1.584443,
+ "mean_val_acc": 45.6167
+ }
+ },
+ "fashion_wide": {
+ "G8": {
+ "execution_feasible": true,
+ "optimization_feasible": true,
+ "baseline_val_nll": 2.311222,
+ "target_val_nll_threshold": 1.848978,
+ "baseline_val_acc": 8.77,
+ "target_val_acc_threshold": 28.77,
+ "mean_val_nll": 1.615937,
+ "mean_val_acc": 41.6667
+ },
+ "G5": {
+ "execution_feasible": true,
+ "optimization_feasible": true,
+ "baseline_val_nll": 2.311222,
+ "target_val_nll_threshold": 1.848978,
+ "baseline_val_acc": 8.77,
+ "target_val_acc_threshold": 28.77,
+ "mean_val_nll": 1.525747,
+ "mean_val_acc": 46.31
+ }
+ }
+ },
+ "resource_totals": {
+ "total_queries": 30720,
+ "total_sample_evaluations": 245760000,
+ "summed_optimization_wall_time_sec": 188.7283,
+ "summed_validation_wall_time_sec": 6.3826,
+ "summed_recorded_run_wall_time_sec": 195.1109,
+ "elapsed_current_process_wall_time_sec": 176.3431
+ }
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v6_phase_b.csv b/benchmark_results/pso_v6_phase_b.csv
new file mode 100644
index 0000000..cbab80d
--- /dev/null
+++ b/benchmark_results/pso_v6_phase_b.csv
@@ -0,0 +1,21 @@
+protocol_version,MNIST-PSO-RAW-V6 1.0.0
+
+--- Phase B Screen Results ---
+config_id,description,val_nll,val_acc_%,queries,sample_evals,wall_time_sec
+G0,exact V5 control,1.183117,67.73,4800,9600000,8.4356
+G1,isolate anisotropic per-tensor scaling,1.437604,62.32,4800,9600000,6.6136
+G2,isolate nonzero launch velocity,1.296105,60.72,4800,9600000,6.6528
+G3,isolate mutation,1.130839,68.07,4800,9600000,6.4943
+G4,velocity x mutation interaction,1.11628,65.76,4800,9600000,6.4837
+G5,test sufficient bound expansion,0.90151,70.93,4800,9600000,6.76
+G6,test broader normalized initialization,0.96129,69.56,4800,9600000,6.7408
+G7,isolate antithetic position coupling against G2,1.291266,58.79,4800,9600000,6.4273
+G8,retained semantic control (public Optimizer),0.883557,70.99,4800,9600000,8.7632
+
+--- Phase B Confirmation Aggregates ---
+config_id,mean_val_acc_%,std_val_acc,mean_val_nll,std_val_nll,num_seeds
+G0,79.526667,0.576397,0.689687,0.008079,3
+G1,76.953333,2.490067,0.833759,0.123667,3
+G5,84.236667,0.903678,0.510297,0.024899,3
+G6,84.25,0.219317,0.503809,0.015789,3
+G8,84.916667,0.988804,0.48144,0.029447,3
diff --git a/benchmark_results/pso_v6_phase_b.json b/benchmark_results/pso_v6_phase_b.json
new file mode 100644
index 0000000..ad9556a
--- /dev/null
+++ b/benchmark_results/pso_v6_phase_b.json
@@ -0,0 +1,59505 @@
+{
+ "protocol_version": "MNIST-PSO-RAW-V6 1.0.0",
+ "pso_version": "4.0.0",
+ "official_test_data_loaded": false,
+ "official_test_evaluations": 0,
+ "data_fingerprint": "26bd2ed5f27e7d24",
+ "base_model_seed": 41,
+ "base_model_fingerprint": "d0eee0ffd33088ed",
+ "geometry_configs": {
+ "G0": {
+ "config_id": "G0",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "exact V5 control"
+ },
+ "G1": {
+ "config_id": "G1",
+ "scale_type": "global_rms",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate anisotropic per-tensor scaling"
+ },
+ "G2": {
+ "config_id": "G2",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate nonzero launch velocity"
+ },
+ "G3": {
+ "config_id": "G3",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate mutation"
+ },
+ "G4": {
+ "config_id": "G4",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "velocity x mutation interaction"
+ },
+ "G5": {
+ "config_id": "G5",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test sufficient bound expansion"
+ },
+ "G6": {
+ "config_id": "G6",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 1.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test broader normalized initialization"
+ },
+ "G7": {
+ "config_id": "G7",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "independent",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate antithetic position coupling against G2"
+ },
+ "G8": {
+ "config_id": "G8",
+ "scale_type": "optimizer_default",
+ "init_position_mode": "independent",
+ "position_radius": 0.05,
+ "initial_velocity_radius": 0.05,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "retained semantic control (public Optimizer)"
+ }
+ },
+ "selection_rule": "lowest_validation_nll_then_highest_accuracy",
+ "provenance": {
+ "input_shape": [
+ 1,
+ 28,
+ 28
+ ],
+ "pca": false,
+ "raw_inputs": true,
+ "normalization_scope": "search_train_50000_only",
+ "train_mean": 0.130682,
+ "train_std": 0.308127,
+ "search_samples": 50000,
+ "val_samples": 10000,
+ "test_samples": 0,
+ "official_test_evaluations": 0,
+ "split_seed": 20260902,
+ "split_fingerprint": "51b289d9f503a9f3"
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.6.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timestamp": "2026-09-02 23:18:03",
+ "screen_payload": {
+ "phase": "screen",
+ "seed": 91,
+ "swarm_size": 30,
+ "epochs": 160,
+ "screen_results": {
+ "G0": {
+ "config_id": "G0",
+ "gbest_loss": 1.147565,
+ "gbest_acc": 69.8,
+ "gbest_val_loss": 1.183117,
+ "gbest_val_acc": 67.73,
+ "val_selected_particle_idx": 8,
+ "val_selected_loss": 1.183117,
+ "val_selected_acc": 67.73,
+ "val_metrics": {
+ "accuracy": 67.73,
+ "nll": 1.183117,
+ "brier": 0.53537,
+ "ece": 0.247347,
+ "margin": 0.248949
+ },
+ "wall_time_sec": 8.4356,
+ "optimization_wall_time_sec": 8.2302,
+ "validation_wall_time_sec": 0.2054,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160
+ ],
+ "pbest_update_counts": 2436,
+ "boundary_hits": 279090,
+ "boundary_occupancy": 0.006391,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.187343,
+ "position_radius": 12.190442,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.319009,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.310269,
+ "gbest_acc": 7.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.302216,
+ "gbest_acc": 9.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.280997,
+ "gbest_acc": 12.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.248806,
+ "gbest_acc": 20.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.22007,
+ "gbest_acc": 24.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.197811,
+ "gbest_acc": 22.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.181172,
+ "gbest_acc": 21.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.14378,
+ "gbest_acc": 19.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.111105,
+ "gbest_acc": 19.3,
+ "val_loss": 2.113562,
+ "val_acc": 20.15
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.065237,
+ "gbest_acc": 21.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.022572,
+ "gbest_acc": 26.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.99992,
+ "gbest_acc": 27.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.970806,
+ "gbest_acc": 30.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.964259,
+ "gbest_acc": 29.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.936239,
+ "gbest_acc": 33.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.932432,
+ "gbest_acc": 33.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.908575,
+ "gbest_acc": 34.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.900177,
+ "gbest_acc": 34.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.893059,
+ "gbest_acc": 35.15,
+ "val_loss": 1.908893,
+ "val_acc": 35.05
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.893059,
+ "gbest_acc": 35.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.889398,
+ "gbest_acc": 35.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.879795,
+ "gbest_acc": 38.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.859706,
+ "gbest_acc": 38.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.844069,
+ "gbest_acc": 37.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.843418,
+ "gbest_acc": 38.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.835918,
+ "gbest_acc": 36.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.825405,
+ "gbest_acc": 37.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.793166,
+ "gbest_acc": 41.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.793166,
+ "gbest_acc": 41.3,
+ "val_loss": 1.813975,
+ "val_acc": 39.9
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.793166,
+ "gbest_acc": 41.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.793166,
+ "gbest_acc": 41.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.783466,
+ "gbest_acc": 41.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.770267,
+ "gbest_acc": 43.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.766128,
+ "gbest_acc": 43.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74411,
+ "gbest_acc": 43.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74411,
+ "gbest_acc": 43.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.722016,
+ "gbest_acc": 45.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.715608,
+ "gbest_acc": 44.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.694592,
+ "gbest_acc": 47.3,
+ "val_loss": 1.7177,
+ "val_acc": 45.68
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687191,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.679955,
+ "gbest_acc": 48.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.665032,
+ "gbest_acc": 47.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.660036,
+ "gbest_acc": 48.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.660036,
+ "gbest_acc": 48.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.656864,
+ "gbest_acc": 50.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.648261,
+ "gbest_acc": 50.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.637429,
+ "gbest_acc": 53.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629559,
+ "gbest_acc": 50.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.627745,
+ "gbest_acc": 49.4,
+ "val_loss": 1.652814,
+ "val_acc": 46.97
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624722,
+ "gbest_acc": 51.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624722,
+ "gbest_acc": 51.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.621271,
+ "gbest_acc": 49.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.603937,
+ "gbest_acc": 51.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.603892,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.574743,
+ "gbest_acc": 54.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566305,
+ "gbest_acc": 56.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566305,
+ "gbest_acc": 56.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566305,
+ "gbest_acc": 56.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.561212,
+ "gbest_acc": 56.3,
+ "val_loss": 1.58474,
+ "val_acc": 53.4
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.550911,
+ "gbest_acc": 54.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.550176,
+ "gbest_acc": 55.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.54394,
+ "gbest_acc": 56.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.538204,
+ "gbest_acc": 55.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.536207,
+ "gbest_acc": 56.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.516027,
+ "gbest_acc": 57.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.514509,
+ "gbest_acc": 56.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.501886,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.501886,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.498765,
+ "gbest_acc": 57.05,
+ "val_loss": 1.530252,
+ "val_acc": 55.27
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.498765,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.494819,
+ "gbest_acc": 58.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.486218,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.486218,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.486218,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.47865,
+ "gbest_acc": 58.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.471761,
+ "gbest_acc": 59.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.470706,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.455133,
+ "gbest_acc": 61.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.447378,
+ "gbest_acc": 62.2,
+ "val_loss": 1.478323,
+ "val_acc": 59.59
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.446284,
+ "gbest_acc": 61.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.444786,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.444786,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.444786,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.426749,
+ "gbest_acc": 63.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.425618,
+ "gbest_acc": 60.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.420136,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.420136,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.414905,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.40597,
+ "gbest_acc": 61.0,
+ "val_loss": 1.439038,
+ "val_acc": 58.65
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.40361,
+ "gbest_acc": 61.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.395106,
+ "gbest_acc": 61.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.395106,
+ "gbest_acc": 61.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.394371,
+ "gbest_acc": 61.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.390707,
+ "gbest_acc": 64.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.38849,
+ "gbest_acc": 62.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.38849,
+ "gbest_acc": 62.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.38849,
+ "gbest_acc": 62.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388122,
+ "gbest_acc": 62.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388122,
+ "gbest_acc": 62.0,
+ "val_loss": 1.419643,
+ "val_acc": 59.72
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388122,
+ "gbest_acc": 62.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.375218,
+ "gbest_acc": 63.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.373271,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362747,
+ "gbest_acc": 64.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362747,
+ "gbest_acc": 64.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.359635,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348393,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348393,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348393,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348393,
+ "gbest_acc": 64.45,
+ "val_loss": 1.38298,
+ "val_acc": 62.02
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.33786,
+ "gbest_acc": 66.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.33786,
+ "gbest_acc": 66.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.333928,
+ "gbest_acc": 66.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.328514,
+ "gbest_acc": 65.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.328241,
+ "gbest_acc": 65.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.321243,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.316853,
+ "gbest_acc": 66.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.314892,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.312831,
+ "gbest_acc": 65.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.312831,
+ "gbest_acc": 65.1,
+ "val_loss": 1.349793,
+ "val_acc": 62.28
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.305485,
+ "gbest_acc": 66.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.299608,
+ "gbest_acc": 66.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.293387,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.293387,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.289006,
+ "gbest_acc": 66.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279774,
+ "gbest_acc": 66.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.273683,
+ "gbest_acc": 67.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.273683,
+ "gbest_acc": 67.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.270333,
+ "gbest_acc": 67.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.270079,
+ "gbest_acc": 66.55,
+ "val_loss": 1.299638,
+ "val_acc": 64.95
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.262235,
+ "gbest_acc": 67.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.256521,
+ "gbest_acc": 67.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240951,
+ "gbest_acc": 67.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240951,
+ "gbest_acc": 67.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240951,
+ "gbest_acc": 67.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240951,
+ "gbest_acc": 67.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.23886,
+ "gbest_acc": 68.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.235466,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.223605,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.218237,
+ "gbest_acc": 68.85,
+ "val_loss": 1.255444,
+ "val_acc": 66.78
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.216309,
+ "gbest_acc": 67.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.214696,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.209994,
+ "gbest_acc": 68.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.206406,
+ "gbest_acc": 67.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.206406,
+ "gbest_acc": 67.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.204739,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.201082,
+ "gbest_acc": 68.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.195486,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.195272,
+ "gbest_acc": 68.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.190521,
+ "gbest_acc": 69.0,
+ "val_loss": 1.233496,
+ "val_acc": 66.27
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.167662,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.167662,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.167662,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.155561,
+ "gbest_acc": 69.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.155403,
+ "gbest_acc": 69.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.150636,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.150636,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.149532,
+ "gbest_acc": 70.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.148374,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.147565,
+ "gbest_acc": 69.8,
+ "val_loss": 1.183117,
+ "val_acc": 67.73
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G0",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "exact V5 control"
+ }
+ },
+ "G1": {
+ "config_id": "G1",
+ "gbest_loss": 1.424766,
+ "gbest_acc": 64.65,
+ "gbest_val_loss": 1.439619,
+ "gbest_val_acc": 62.89,
+ "val_selected_particle_idx": 15,
+ "val_selected_loss": 1.437604,
+ "val_selected_acc": 62.32,
+ "val_metrics": {
+ "accuracy": 62.32,
+ "nll": 1.437604,
+ "brier": 0.638084,
+ "ece": 0.309309,
+ "margin": 0.143863
+ },
+ "wall_time_sec": 6.6136,
+ "optimization_wall_time_sec": 6.4264,
+ "validation_wall_time_sec": 0.1871,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160
+ ],
+ "pbest_update_counts": 2515,
+ "boundary_hits": 347542,
+ "boundary_occupancy": 0.007958,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.171411,
+ "position_radius": 12.100932,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.315947,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.308322,
+ "gbest_acc": 10.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.294986,
+ "gbest_acc": 10.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.273571,
+ "gbest_acc": 12.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.253161,
+ "gbest_acc": 12.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.222763,
+ "gbest_acc": 16.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.192668,
+ "gbest_acc": 19.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.173146,
+ "gbest_acc": 22.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.150064,
+ "gbest_acc": 28.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.136011,
+ "gbest_acc": 29.85,
+ "val_loss": 2.14699,
+ "val_acc": 26.68
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.12312,
+ "gbest_acc": 29.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.114006,
+ "gbest_acc": 32.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.095677,
+ "gbest_acc": 29.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.085551,
+ "gbest_acc": 31.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.068933,
+ "gbest_acc": 31.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.052427,
+ "gbest_acc": 31.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.043275,
+ "gbest_acc": 32.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.034469,
+ "gbest_acc": 30.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.027554,
+ "gbest_acc": 32.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.021309,
+ "gbest_acc": 28.8,
+ "val_loss": 2.033511,
+ "val_acc": 27.52
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.009541,
+ "gbest_acc": 30.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.005577,
+ "gbest_acc": 33.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.997396,
+ "gbest_acc": 37.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.988852,
+ "gbest_acc": 35.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.967112,
+ "gbest_acc": 37.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.955614,
+ "gbest_acc": 37.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.954019,
+ "gbest_acc": 37.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.954019,
+ "gbest_acc": 37.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.952413,
+ "gbest_acc": 36.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.929805,
+ "gbest_acc": 43.45,
+ "val_loss": 1.9382,
+ "val_acc": 42.12
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.929805,
+ "gbest_acc": 43.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.929805,
+ "gbest_acc": 43.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.929805,
+ "gbest_acc": 43.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.92051,
+ "gbest_acc": 42.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.904802,
+ "gbest_acc": 43.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.881655,
+ "gbest_acc": 47.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.866855,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.862242,
+ "gbest_acc": 45.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.862242,
+ "gbest_acc": 45.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.862242,
+ "gbest_acc": 45.05,
+ "val_loss": 1.870654,
+ "val_acc": 44.47
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.848211,
+ "gbest_acc": 46.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.830021,
+ "gbest_acc": 49.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.824273,
+ "gbest_acc": 47.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.821906,
+ "gbest_acc": 49.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.821078,
+ "gbest_acc": 49.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.821078,
+ "gbest_acc": 49.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.818256,
+ "gbest_acc": 49.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.806508,
+ "gbest_acc": 49.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.806508,
+ "gbest_acc": 49.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.806508,
+ "gbest_acc": 49.7,
+ "val_loss": 1.812953,
+ "val_acc": 47.06
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.801929,
+ "gbest_acc": 50.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.791898,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.791898,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.791898,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.790438,
+ "gbest_acc": 52.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.784344,
+ "gbest_acc": 53.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.782505,
+ "gbest_acc": 50.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.780576,
+ "gbest_acc": 50.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.772899,
+ "gbest_acc": 49.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.754965,
+ "gbest_acc": 51.05,
+ "val_loss": 1.766327,
+ "val_acc": 48.98
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.747439,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.747439,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.743661,
+ "gbest_acc": 52.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.740029,
+ "gbest_acc": 52.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.73525,
+ "gbest_acc": 54.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.731287,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.727312,
+ "gbest_acc": 54.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.72605,
+ "gbest_acc": 55.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.72605,
+ "gbest_acc": 55.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.717518,
+ "gbest_acc": 55.85,
+ "val_loss": 1.727644,
+ "val_acc": 54.48
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.717518,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.714798,
+ "gbest_acc": 54.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.714798,
+ "gbest_acc": 54.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711542,
+ "gbest_acc": 53.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.708385,
+ "gbest_acc": 56.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.708385,
+ "gbest_acc": 56.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.705886,
+ "gbest_acc": 55.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.694518,
+ "gbest_acc": 56.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.694518,
+ "gbest_acc": 56.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.691288,
+ "gbest_acc": 55.95,
+ "val_loss": 1.698494,
+ "val_acc": 54.14
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.685534,
+ "gbest_acc": 55.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675454,
+ "gbest_acc": 54.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.670128,
+ "gbest_acc": 55.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.661029,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.661029,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.660406,
+ "gbest_acc": 56.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.660406,
+ "gbest_acc": 56.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.649995,
+ "gbest_acc": 57.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.648547,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.6459,
+ "gbest_acc": 55.5,
+ "val_loss": 1.655206,
+ "val_acc": 54.85
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.641742,
+ "gbest_acc": 58.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629151,
+ "gbest_acc": 57.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629151,
+ "gbest_acc": 57.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.623244,
+ "gbest_acc": 55.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.617541,
+ "gbest_acc": 57.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.615795,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.610377,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.610377,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.606006,
+ "gbest_acc": 56.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.593474,
+ "gbest_acc": 57.85,
+ "val_loss": 1.603899,
+ "val_acc": 57.46
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.593474,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.584104,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.584104,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.584104,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.583131,
+ "gbest_acc": 58.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.577354,
+ "gbest_acc": 57.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.575562,
+ "gbest_acc": 58.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.570815,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.570815,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.569771,
+ "gbest_acc": 58.7,
+ "val_loss": 1.57983,
+ "val_acc": 57.85
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.556539,
+ "gbest_acc": 58.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.556348,
+ "gbest_acc": 59.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.549969,
+ "gbest_acc": 57.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.549892,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.53986,
+ "gbest_acc": 59.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.535266,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.535266,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.535266,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.535266,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.530102,
+ "gbest_acc": 60.45,
+ "val_loss": 1.541431,
+ "val_acc": 58.95
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.529386,
+ "gbest_acc": 60.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.528412,
+ "gbest_acc": 59.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52669,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52669,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.519616,
+ "gbest_acc": 62.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.515662,
+ "gbest_acc": 61.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.515231,
+ "gbest_acc": 60.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.510802,
+ "gbest_acc": 59.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.509791,
+ "gbest_acc": 61.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.506625,
+ "gbest_acc": 61.1,
+ "val_loss": 1.516113,
+ "val_acc": 59.4
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.500361,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.500361,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.494626,
+ "gbest_acc": 61.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.494626,
+ "gbest_acc": 61.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.487294,
+ "gbest_acc": 62.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.485371,
+ "gbest_acc": 62.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.485371,
+ "gbest_acc": 62.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.485371,
+ "gbest_acc": 62.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.47923,
+ "gbest_acc": 62.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.476306,
+ "gbest_acc": 62.8,
+ "val_loss": 1.487363,
+ "val_acc": 61.41
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.476306,
+ "gbest_acc": 62.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474686,
+ "gbest_acc": 61.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.469395,
+ "gbest_acc": 62.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.468387,
+ "gbest_acc": 63.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.461817,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.461817,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.461817,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.456501,
+ "gbest_acc": 64.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452649,
+ "gbest_acc": 63.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452649,
+ "gbest_acc": 63.15,
+ "val_loss": 1.46415,
+ "val_acc": 61.72
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.450157,
+ "gbest_acc": 63.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.445838,
+ "gbest_acc": 64.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.440069,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.435774,
+ "gbest_acc": 65.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.433747,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.431516,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.431516,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.431516,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.429243,
+ "gbest_acc": 64.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.424766,
+ "gbest_acc": 64.65,
+ "val_loss": 1.439619,
+ "val_acc": 62.89
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G1",
+ "scale_type": "global_rms",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate anisotropic per-tensor scaling"
+ }
+ },
+ "G2": {
+ "config_id": "G2",
+ "gbest_loss": 1.260671,
+ "gbest_acc": 63.2,
+ "gbest_val_loss": 1.298475,
+ "gbest_val_acc": 60.76,
+ "val_selected_particle_idx": 11,
+ "val_selected_loss": 1.296105,
+ "val_selected_acc": 60.72,
+ "val_metrics": {
+ "accuracy": 60.72,
+ "nll": 1.296105,
+ "brier": 0.585207,
+ "ece": 0.186668,
+ "margin": 0.235434
+ },
+ "wall_time_sec": 6.6528,
+ "optimization_wall_time_sec": 6.4626,
+ "validation_wall_time_sec": 0.1902,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160
+ ],
+ "pbest_update_counts": 2335,
+ "boundary_hits": 217768,
+ "boundary_occupancy": 0.004987,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.127313,
+ "position_radius": 8.553208,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.319009,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.303509,
+ "gbest_acc": 9.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.296052,
+ "gbest_acc": 9.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.262821,
+ "gbest_acc": 10.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.247507,
+ "gbest_acc": 12.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.222965,
+ "gbest_acc": 14.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.19646,
+ "gbest_acc": 16.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.14694,
+ "gbest_acc": 17.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.119284,
+ "gbest_acc": 20.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.077625,
+ "gbest_acc": 20.8,
+ "val_loss": 2.075401,
+ "val_acc": 21.73
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.048708,
+ "gbest_acc": 23.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.042735,
+ "gbest_acc": 28.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.042735,
+ "gbest_acc": 28.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.037079,
+ "gbest_acc": 33.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.030461,
+ "gbest_acc": 27.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.029878,
+ "gbest_acc": 29.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.012703,
+ "gbest_acc": 31.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.012703,
+ "gbest_acc": 31.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.004503,
+ "gbest_acc": 33.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.997764,
+ "gbest_acc": 32.8,
+ "val_loss": 2.006228,
+ "val_acc": 32.64
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.953959,
+ "gbest_acc": 35.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.953959,
+ "gbest_acc": 35.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.951544,
+ "gbest_acc": 30.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.913776,
+ "gbest_acc": 34.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.913776,
+ "gbest_acc": 34.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.913776,
+ "gbest_acc": 34.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.908982,
+ "gbest_acc": 33.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.908982,
+ "gbest_acc": 33.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.907122,
+ "gbest_acc": 33.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.901545,
+ "gbest_acc": 34.1,
+ "val_loss": 1.897862,
+ "val_acc": 34.22
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.850567,
+ "gbest_acc": 38.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.850567,
+ "gbest_acc": 38.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.850567,
+ "gbest_acc": 38.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.840613,
+ "gbest_acc": 38.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.840501,
+ "gbest_acc": 36.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.823124,
+ "gbest_acc": 40.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.823124,
+ "gbest_acc": 40.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.800574,
+ "gbest_acc": 39.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.787842,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.78207,
+ "gbest_acc": 40.8,
+ "val_loss": 1.789581,
+ "val_acc": 39.88
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.764248,
+ "gbest_acc": 42.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.764248,
+ "gbest_acc": 42.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.764248,
+ "gbest_acc": 42.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.750987,
+ "gbest_acc": 45.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.750987,
+ "gbest_acc": 45.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.742348,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.742348,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74108,
+ "gbest_acc": 46.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730096,
+ "gbest_acc": 46.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730096,
+ "gbest_acc": 46.25,
+ "val_loss": 1.744376,
+ "val_acc": 45.5
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730096,
+ "gbest_acc": 46.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730096,
+ "gbest_acc": 46.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.72351,
+ "gbest_acc": 43.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.707215,
+ "gbest_acc": 46.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.705108,
+ "gbest_acc": 48.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.698384,
+ "gbest_acc": 45.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687789,
+ "gbest_acc": 46.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687789,
+ "gbest_acc": 46.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.683239,
+ "gbest_acc": 46.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.677621,
+ "gbest_acc": 47.0,
+ "val_loss": 1.691962,
+ "val_acc": 46.35
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.67126,
+ "gbest_acc": 45.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.67126,
+ "gbest_acc": 45.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.67126,
+ "gbest_acc": 45.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.668337,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.659695,
+ "gbest_acc": 46.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.659695,
+ "gbest_acc": 46.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.657354,
+ "gbest_acc": 47.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.657354,
+ "gbest_acc": 47.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.657354,
+ "gbest_acc": 47.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.650023,
+ "gbest_acc": 48.3,
+ "val_loss": 1.662783,
+ "val_acc": 48.16
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.650023,
+ "gbest_acc": 48.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.650023,
+ "gbest_acc": 48.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.640128,
+ "gbest_acc": 47.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.628654,
+ "gbest_acc": 48.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.618027,
+ "gbest_acc": 51.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.61674,
+ "gbest_acc": 50.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.61674,
+ "gbest_acc": 50.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.600559,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.598821,
+ "gbest_acc": 50.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585512,
+ "gbest_acc": 50.05,
+ "val_loss": 1.603782,
+ "val_acc": 50.01
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585512,
+ "gbest_acc": 50.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585512,
+ "gbest_acc": 50.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.565692,
+ "gbest_acc": 50.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.545885,
+ "gbest_acc": 52.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.543613,
+ "gbest_acc": 52.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.543613,
+ "gbest_acc": 52.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.543613,
+ "gbest_acc": 52.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.535578,
+ "gbest_acc": 52.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.529132,
+ "gbest_acc": 55.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.524492,
+ "gbest_acc": 52.8,
+ "val_loss": 1.551724,
+ "val_acc": 51.83
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.524492,
+ "gbest_acc": 52.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.524492,
+ "gbest_acc": 52.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.524492,
+ "gbest_acc": 52.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.518399,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.518399,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.518399,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497453,
+ "gbest_acc": 55.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497453,
+ "gbest_acc": 55.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497453,
+ "gbest_acc": 55.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.491416,
+ "gbest_acc": 53.85,
+ "val_loss": 1.521564,
+ "val_acc": 51.36
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474938,
+ "gbest_acc": 55.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474938,
+ "gbest_acc": 55.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460145,
+ "gbest_acc": 54.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460145,
+ "gbest_acc": 54.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.453022,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.446806,
+ "gbest_acc": 54.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.434058,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.427915,
+ "gbest_acc": 55.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.426081,
+ "gbest_acc": 55.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.422212,
+ "gbest_acc": 55.75,
+ "val_loss": 1.461187,
+ "val_acc": 53.99
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.421268,
+ "gbest_acc": 55.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.413391,
+ "gbest_acc": 55.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.408327,
+ "gbest_acc": 55.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.404039,
+ "gbest_acc": 56.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401398,
+ "gbest_acc": 57.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401398,
+ "gbest_acc": 57.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401398,
+ "gbest_acc": 57.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.397829,
+ "gbest_acc": 57.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.392224,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.392224,
+ "gbest_acc": 57.05,
+ "val_loss": 1.429698,
+ "val_acc": 54.84
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.387502,
+ "gbest_acc": 57.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.384152,
+ "gbest_acc": 57.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.37996,
+ "gbest_acc": 56.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.376825,
+ "gbest_acc": 56.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.374364,
+ "gbest_acc": 56.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.37091,
+ "gbest_acc": 57.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.369904,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.361282,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357682,
+ "gbest_acc": 58.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.356437,
+ "gbest_acc": 59.2,
+ "val_loss": 1.392462,
+ "val_acc": 56.2
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.353375,
+ "gbest_acc": 58.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.352903,
+ "gbest_acc": 57.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.344424,
+ "gbest_acc": 58.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.340071,
+ "gbest_acc": 58.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338086,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.334613,
+ "gbest_acc": 58.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332369,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332369,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331179,
+ "gbest_acc": 58.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.324061,
+ "gbest_acc": 59.3,
+ "val_loss": 1.360066,
+ "val_acc": 57.89
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.313231,
+ "gbest_acc": 59.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.313231,
+ "gbest_acc": 59.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.308882,
+ "gbest_acc": 59.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.305071,
+ "gbest_acc": 60.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.305071,
+ "gbest_acc": 60.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.297366,
+ "gbest_acc": 60.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.295663,
+ "gbest_acc": 60.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.294579,
+ "gbest_acc": 61.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.28834,
+ "gbest_acc": 61.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.286525,
+ "gbest_acc": 61.8,
+ "val_loss": 1.323947,
+ "val_acc": 59.65
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.286525,
+ "gbest_acc": 61.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.284404,
+ "gbest_acc": 62.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279623,
+ "gbest_acc": 62.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.274098,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.272405,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.270274,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.270274,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.267652,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.263967,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.260671,
+ "gbest_acc": 63.2,
+ "val_loss": 1.298475,
+ "val_acc": 60.76
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G2",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate nonzero launch velocity"
+ }
+ },
+ "G3": {
+ "config_id": "G3",
+ "gbest_loss": 1.101833,
+ "gbest_acc": 70.5,
+ "gbest_val_loss": 1.130839,
+ "gbest_val_acc": 68.07,
+ "val_selected_particle_idx": 22,
+ "val_selected_loss": 1.130839,
+ "val_selected_acc": 68.07,
+ "val_metrics": {
+ "accuracy": 68.07,
+ "nll": 1.130839,
+ "brier": 0.513959,
+ "ece": 0.226902,
+ "margin": 0.271513
+ },
+ "wall_time_sec": 6.4943,
+ "optimization_wall_time_sec": 6.3127,
+ "validation_wall_time_sec": 0.1817,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 88,
+ "final_moment_steps": [
+ 31,
+ 46,
+ 47,
+ 118,
+ 13,
+ 16,
+ 41,
+ 42,
+ 41,
+ 76,
+ 160,
+ 28,
+ 3,
+ 11,
+ 43,
+ 59,
+ 14,
+ 56,
+ 8,
+ 107,
+ 4,
+ 36,
+ 17,
+ 41,
+ 34,
+ 17,
+ 31,
+ 88,
+ 4,
+ 83
+ ],
+ "pbest_update_counts": 2576,
+ "boundary_hits": 273258,
+ "boundary_occupancy": 0.006257,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.161481,
+ "position_radius": 11.811624,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.319009,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.310269,
+ "gbest_acc": 7.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.302216,
+ "gbest_acc": 9.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.280997,
+ "gbest_acc": 12.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.248806,
+ "gbest_acc": 20.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.22007,
+ "gbest_acc": 24.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.197811,
+ "gbest_acc": 22.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.181172,
+ "gbest_acc": 21.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.159871,
+ "gbest_acc": 20.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.136736,
+ "gbest_acc": 21.3,
+ "val_loss": 2.134861,
+ "val_acc": 22.43
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.114397,
+ "gbest_acc": 25.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.084893,
+ "gbest_acc": 28.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.061571,
+ "gbest_acc": 29.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.032724,
+ "gbest_acc": 34.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.013328,
+ "gbest_acc": 33.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.993989,
+ "gbest_acc": 32.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.979469,
+ "gbest_acc": 33.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.979469,
+ "gbest_acc": 33.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.979469,
+ "gbest_acc": 33.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.97274,
+ "gbest_acc": 34.7,
+ "val_loss": 1.983832,
+ "val_acc": 34.16
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.967456,
+ "gbest_acc": 34.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.964252,
+ "gbest_acc": 35.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.964252,
+ "gbest_acc": 35.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.962797,
+ "gbest_acc": 35.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.953577,
+ "gbest_acc": 37.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.948298,
+ "gbest_acc": 37.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.940264,
+ "gbest_acc": 40.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.920149,
+ "gbest_acc": 40.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.919143,
+ "gbest_acc": 40.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.914726,
+ "gbest_acc": 39.2,
+ "val_loss": 1.925831,
+ "val_acc": 39.53
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.904199,
+ "gbest_acc": 40.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.887915,
+ "gbest_acc": 40.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.862978,
+ "gbest_acc": 39.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.855988,
+ "gbest_acc": 41.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.855988,
+ "gbest_acc": 41.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.855988,
+ "gbest_acc": 41.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.855988,
+ "gbest_acc": 41.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.848551,
+ "gbest_acc": 39.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.846189,
+ "gbest_acc": 40.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.820285,
+ "gbest_acc": 40.65,
+ "val_loss": 1.835167,
+ "val_acc": 38.95
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.808691,
+ "gbest_acc": 41.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.808691,
+ "gbest_acc": 41.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.800475,
+ "gbest_acc": 41.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.780675,
+ "gbest_acc": 41.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.772191,
+ "gbest_acc": 43.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.759504,
+ "gbest_acc": 40.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.744899,
+ "gbest_acc": 44.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711915,
+ "gbest_acc": 45.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.709915,
+ "gbest_acc": 43.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.694066,
+ "gbest_acc": 45.65,
+ "val_loss": 1.713861,
+ "val_acc": 44.24
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.693825,
+ "gbest_acc": 48.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.686315,
+ "gbest_acc": 48.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.667942,
+ "gbest_acc": 48.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.664553,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.664553,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.654114,
+ "gbest_acc": 50.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.639485,
+ "gbest_acc": 47.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629218,
+ "gbest_acc": 46.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.625734,
+ "gbest_acc": 45.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.612302,
+ "gbest_acc": 49.45,
+ "val_loss": 1.628001,
+ "val_acc": 49.78
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.606189,
+ "gbest_acc": 51.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.605763,
+ "gbest_acc": 49.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.582973,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.582973,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.571994,
+ "gbest_acc": 51.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.571994,
+ "gbest_acc": 51.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.563389,
+ "gbest_acc": 52.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.543682,
+ "gbest_acc": 55.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.523503,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52179,
+ "gbest_acc": 54.75,
+ "val_loss": 1.537683,
+ "val_acc": 54.22
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52179,
+ "gbest_acc": 54.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.520642,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.50233,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497037,
+ "gbest_acc": 55.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497037,
+ "gbest_acc": 55.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497037,
+ "gbest_acc": 55.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.495274,
+ "gbest_acc": 55.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.492267,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.484278,
+ "gbest_acc": 56.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.468022,
+ "gbest_acc": 57.25,
+ "val_loss": 1.490051,
+ "val_acc": 55.55
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.464147,
+ "gbest_acc": 57.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460034,
+ "gbest_acc": 57.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.444612,
+ "gbest_acc": 57.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.444612,
+ "gbest_acc": 57.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.441682,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.430969,
+ "gbest_acc": 57.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.430969,
+ "gbest_acc": 57.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.414128,
+ "gbest_acc": 58.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.414128,
+ "gbest_acc": 58.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.407198,
+ "gbest_acc": 58.15,
+ "val_loss": 1.433016,
+ "val_acc": 57.1
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.384158,
+ "gbest_acc": 59.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.382746,
+ "gbest_acc": 60.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.367198,
+ "gbest_acc": 60.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.364888,
+ "gbest_acc": 60.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.359646,
+ "gbest_acc": 59.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.358774,
+ "gbest_acc": 59.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.353043,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.347814,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.342674,
+ "gbest_acc": 60.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.330429,
+ "gbest_acc": 61.0,
+ "val_loss": 1.34453,
+ "val_acc": 60.52
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.328923,
+ "gbest_acc": 60.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.32153,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.320176,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.304767,
+ "gbest_acc": 62.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.304732,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.304732,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.304732,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.303363,
+ "gbest_acc": 61.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282837,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282837,
+ "gbest_acc": 63.3,
+ "val_loss": 1.298784,
+ "val_acc": 60.86
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282837,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.280779,
+ "gbest_acc": 62.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.280779,
+ "gbest_acc": 62.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.271439,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26861,
+ "gbest_acc": 64.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.263372,
+ "gbest_acc": 63.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.263372,
+ "gbest_acc": 63.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.259126,
+ "gbest_acc": 64.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.254396,
+ "gbest_acc": 64.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.245999,
+ "gbest_acc": 64.35,
+ "val_loss": 1.26705,
+ "val_acc": 62.56
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.235562,
+ "gbest_acc": 65.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.235562,
+ "gbest_acc": 65.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.22955,
+ "gbest_acc": 64.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.221117,
+ "gbest_acc": 65.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.221117,
+ "gbest_acc": 65.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.220666,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.209499,
+ "gbest_acc": 65.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.204967,
+ "gbest_acc": 65.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.204547,
+ "gbest_acc": 63.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.193624,
+ "gbest_acc": 64.25,
+ "val_loss": 1.209377,
+ "val_acc": 63.59
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.180667,
+ "gbest_acc": 65.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.168593,
+ "gbest_acc": 65.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.162642,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.162642,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.162642,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.159592,
+ "gbest_acc": 68.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.148466,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.148466,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.147935,
+ "gbest_acc": 68.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146317,
+ "gbest_acc": 67.35,
+ "val_loss": 1.16723,
+ "val_acc": 66.6
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.144767,
+ "gbest_acc": 67.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.144767,
+ "gbest_acc": 67.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.134513,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.134513,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.134513,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132542,
+ "gbest_acc": 68.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132542,
+ "gbest_acc": 68.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.128464,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12701,
+ "gbest_acc": 69.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12701,
+ "gbest_acc": 69.15,
+ "val_loss": 1.152151,
+ "val_acc": 67.67
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12701,
+ "gbest_acc": 69.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12701,
+ "gbest_acc": 69.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.120452,
+ "gbest_acc": 68.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.116909,
+ "gbest_acc": 68.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.109736,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.107309,
+ "gbest_acc": 68.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106793,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106793,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.103275,
+ "gbest_acc": 69.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.101833,
+ "gbest_acc": 70.5,
+ "val_loss": 1.130839,
+ "val_acc": 68.07
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G3",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate mutation"
+ }
+ },
+ "G4": {
+ "config_id": "G4",
+ "gbest_loss": 1.06531,
+ "gbest_acc": 67.7,
+ "gbest_val_loss": 1.11628,
+ "gbest_val_acc": 65.76,
+ "val_selected_particle_idx": 18,
+ "val_selected_loss": 1.11628,
+ "val_selected_acc": 65.76,
+ "val_metrics": {
+ "accuracy": 65.76,
+ "nll": 1.11628,
+ "brier": 0.514631,
+ "ece": 0.174604,
+ "margin": 0.291075
+ },
+ "wall_time_sec": 6.4837,
+ "optimization_wall_time_sec": 6.3022,
+ "validation_wall_time_sec": 0.1815,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 88,
+ "final_moment_steps": [
+ 31,
+ 46,
+ 47,
+ 118,
+ 13,
+ 16,
+ 41,
+ 42,
+ 41,
+ 76,
+ 160,
+ 28,
+ 3,
+ 11,
+ 43,
+ 59,
+ 14,
+ 56,
+ 8,
+ 107,
+ 4,
+ 36,
+ 17,
+ 41,
+ 34,
+ 17,
+ 31,
+ 88,
+ 4,
+ 83
+ ],
+ "pbest_update_counts": 2125,
+ "boundary_hits": 317925,
+ "boundary_occupancy": 0.00728,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.136519,
+ "position_radius": 10.236586,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.319009,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.303509,
+ "gbest_acc": 9.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.296052,
+ "gbest_acc": 9.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.262821,
+ "gbest_acc": 10.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.247507,
+ "gbest_acc": 12.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.222965,
+ "gbest_acc": 14.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.19646,
+ "gbest_acc": 16.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.14694,
+ "gbest_acc": 17.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.119284,
+ "gbest_acc": 20.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.077625,
+ "gbest_acc": 20.8,
+ "val_loss": 2.075401,
+ "val_acc": 21.73
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.048708,
+ "gbest_acc": 23.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.042735,
+ "gbest_acc": 28.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.042735,
+ "gbest_acc": 28.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.037079,
+ "gbest_acc": 33.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.037079,
+ "gbest_acc": 33.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.034766,
+ "gbest_acc": 32.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.031814,
+ "gbest_acc": 33.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.012494,
+ "gbest_acc": 32.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.003936,
+ "gbest_acc": 36.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.985062,
+ "gbest_acc": 36.35,
+ "val_loss": 1.990384,
+ "val_acc": 37.17
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.977002,
+ "gbest_acc": 33.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.950469,
+ "gbest_acc": 34.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.9143,
+ "gbest_acc": 36.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.9143,
+ "gbest_acc": 36.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.90773,
+ "gbest_acc": 36.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.90773,
+ "gbest_acc": 36.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883531,
+ "gbest_acc": 35.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883531,
+ "gbest_acc": 35.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.878594,
+ "gbest_acc": 36.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.847759,
+ "gbest_acc": 39.4,
+ "val_loss": 1.880379,
+ "val_acc": 37.86
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.847759,
+ "gbest_acc": 39.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.835037,
+ "gbest_acc": 41.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.820522,
+ "gbest_acc": 41.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.817504,
+ "gbest_acc": 40.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.806495,
+ "gbest_acc": 39.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.795688,
+ "gbest_acc": 39.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.783437,
+ "gbest_acc": 41.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.783437,
+ "gbest_acc": 41.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.783437,
+ "gbest_acc": 41.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.780061,
+ "gbest_acc": 40.4,
+ "val_loss": 1.816181,
+ "val_acc": 40.71
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.7647,
+ "gbest_acc": 40.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.755221,
+ "gbest_acc": 42.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.755221,
+ "gbest_acc": 42.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74276,
+ "gbest_acc": 40.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74276,
+ "gbest_acc": 40.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.716747,
+ "gbest_acc": 42.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.716747,
+ "gbest_acc": 42.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.716747,
+ "gbest_acc": 42.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.703336,
+ "gbest_acc": 43.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.681799,
+ "gbest_acc": 44.75,
+ "val_loss": 1.727276,
+ "val_acc": 42.2
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.681799,
+ "gbest_acc": 44.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.681799,
+ "gbest_acc": 44.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.661754,
+ "gbest_acc": 44.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.656639,
+ "gbest_acc": 44.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.656639,
+ "gbest_acc": 44.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.656079,
+ "gbest_acc": 44.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.648248,
+ "gbest_acc": 43.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.642714,
+ "gbest_acc": 45.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.642714,
+ "gbest_acc": 45.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.642714,
+ "gbest_acc": 45.25,
+ "val_loss": 1.691618,
+ "val_acc": 43.29
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.618805,
+ "gbest_acc": 47.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.618805,
+ "gbest_acc": 47.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.599923,
+ "gbest_acc": 47.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.599923,
+ "gbest_acc": 47.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.599923,
+ "gbest_acc": 47.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.599923,
+ "gbest_acc": 47.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.590378,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.584632,
+ "gbest_acc": 47.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.584632,
+ "gbest_acc": 47.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.576327,
+ "gbest_acc": 49.05,
+ "val_loss": 1.632185,
+ "val_acc": 46.72
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.574419,
+ "gbest_acc": 49.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.564718,
+ "gbest_acc": 50.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.55848,
+ "gbest_acc": 48.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.55148,
+ "gbest_acc": 50.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.523769,
+ "gbest_acc": 50.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.512382,
+ "gbest_acc": 53.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.507042,
+ "gbest_acc": 51.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.499844,
+ "gbest_acc": 52.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.481997,
+ "gbest_acc": 53.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.47558,
+ "gbest_acc": 52.5,
+ "val_loss": 1.536835,
+ "val_acc": 49.09
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.47558,
+ "gbest_acc": 52.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.47558,
+ "gbest_acc": 52.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474314,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474314,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474314,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.465071,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452196,
+ "gbest_acc": 52.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452196,
+ "gbest_acc": 52.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.433057,
+ "gbest_acc": 54.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.433057,
+ "gbest_acc": 54.6,
+ "val_loss": 1.496624,
+ "val_acc": 50.63
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.431054,
+ "gbest_acc": 53.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.423613,
+ "gbest_acc": 54.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.41836,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.399859,
+ "gbest_acc": 55.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388518,
+ "gbest_acc": 54.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.38389,
+ "gbest_acc": 55.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.380144,
+ "gbest_acc": 53.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.380144,
+ "gbest_acc": 53.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.380144,
+ "gbest_acc": 53.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.378148,
+ "gbest_acc": 54.15,
+ "val_loss": 1.440742,
+ "val_acc": 51.27
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.378148,
+ "gbest_acc": 54.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.378148,
+ "gbest_acc": 54.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.36134,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357391,
+ "gbest_acc": 54.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.349367,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348895,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.34134,
+ "gbest_acc": 58.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.334369,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.33206,
+ "gbest_acc": 56.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.33206,
+ "gbest_acc": 56.6,
+ "val_loss": 1.393573,
+ "val_acc": 53.57
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.326479,
+ "gbest_acc": 58.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.313742,
+ "gbest_acc": 59.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.312688,
+ "gbest_acc": 58.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.311805,
+ "gbest_acc": 59.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.311805,
+ "gbest_acc": 59.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.301076,
+ "gbest_acc": 59.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.298557,
+ "gbest_acc": 60.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.298352,
+ "gbest_acc": 59.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.296019,
+ "gbest_acc": 59.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.289547,
+ "gbest_acc": 59.55,
+ "val_loss": 1.347633,
+ "val_acc": 58.18
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282772,
+ "gbest_acc": 59.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282772,
+ "gbest_acc": 59.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282772,
+ "gbest_acc": 59.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.28153,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.271947,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.253498,
+ "gbest_acc": 61.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.253498,
+ "gbest_acc": 61.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.253498,
+ "gbest_acc": 61.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.238798,
+ "gbest_acc": 62.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.237215,
+ "gbest_acc": 62.4,
+ "val_loss": 1.302051,
+ "val_acc": 59.53
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.226809,
+ "gbest_acc": 63.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.221308,
+ "gbest_acc": 61.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.20915,
+ "gbest_acc": 63.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.200485,
+ "gbest_acc": 63.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.190487,
+ "gbest_acc": 62.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.176096,
+ "gbest_acc": 63.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.15428,
+ "gbest_acc": 64.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136401,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136401,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136401,
+ "gbest_acc": 64.45,
+ "val_loss": 1.190695,
+ "val_acc": 62.53
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136401,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136401,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.130512,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.130512,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.124619,
+ "gbest_acc": 64.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.120104,
+ "gbest_acc": 64.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.114364,
+ "gbest_acc": 65.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.111627,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.109958,
+ "gbest_acc": 65.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.108095,
+ "gbest_acc": 64.85,
+ "val_loss": 1.157127,
+ "val_acc": 64.12
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.108095,
+ "gbest_acc": 64.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.105296,
+ "gbest_acc": 65.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.099184,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.094836,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.091118,
+ "gbest_acc": 66.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.088371,
+ "gbest_acc": 66.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.080286,
+ "gbest_acc": 66.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.073145,
+ "gbest_acc": 67.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.06531,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.06531,
+ "gbest_acc": 67.7,
+ "val_loss": 1.11628,
+ "val_acc": 65.76
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G4",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "velocity x mutation interaction"
+ }
+ },
+ "G5": {
+ "config_id": "G5",
+ "gbest_loss": 0.87666,
+ "gbest_acc": 71.9,
+ "gbest_val_loss": 0.90151,
+ "gbest_val_acc": 70.93,
+ "val_selected_particle_idx": 3,
+ "val_selected_loss": 0.90151,
+ "val_selected_acc": 70.93,
+ "val_metrics": {
+ "accuracy": 70.93,
+ "nll": 0.90151,
+ "brier": 0.410921,
+ "ece": 0.060203,
+ "margin": 0.48728
+ },
+ "wall_time_sec": 6.76,
+ "optimization_wall_time_sec": 6.5753,
+ "validation_wall_time_sec": 0.1847,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 88,
+ "final_moment_steps": [
+ 31,
+ 46,
+ 47,
+ 118,
+ 13,
+ 16,
+ 41,
+ 42,
+ 41,
+ 76,
+ 160,
+ 28,
+ 3,
+ 11,
+ 43,
+ 59,
+ 14,
+ 56,
+ 8,
+ 107,
+ 4,
+ 36,
+ 17,
+ 41,
+ 34,
+ 17,
+ 31,
+ 88,
+ 4,
+ 83
+ ],
+ "pbest_update_counts": 2066,
+ "boundary_hits": 62745,
+ "boundary_occupancy": 0.001437,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.171313,
+ "position_radius": 12.260184,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.319009,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.303509,
+ "gbest_acc": 9.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.296052,
+ "gbest_acc": 9.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.262821,
+ "gbest_acc": 10.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.244346,
+ "gbest_acc": 12.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.22311,
+ "gbest_acc": 15.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.19362,
+ "gbest_acc": 12.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.173948,
+ "gbest_acc": 12.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.158491,
+ "gbest_acc": 17.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.128641,
+ "gbest_acc": 16.15,
+ "val_loss": 2.123287,
+ "val_acc": 16.73
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.10669,
+ "gbest_acc": 17.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.10669,
+ "gbest_acc": 17.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.076173,
+ "gbest_acc": 18.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.026621,
+ "gbest_acc": 23.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.959617,
+ "gbest_acc": 26.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.866877,
+ "gbest_acc": 30.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.819121,
+ "gbest_acc": 36.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.819121,
+ "gbest_acc": 36.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.780743,
+ "gbest_acc": 38.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.774729,
+ "gbest_acc": 39.75,
+ "val_loss": 1.77838,
+ "val_acc": 39.43
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.688082,
+ "gbest_acc": 43.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687632,
+ "gbest_acc": 41.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687632,
+ "gbest_acc": 41.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.673908,
+ "gbest_acc": 43.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.653132,
+ "gbest_acc": 43.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.642928,
+ "gbest_acc": 43.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.628932,
+ "gbest_acc": 44.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.628932,
+ "gbest_acc": 44.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.626379,
+ "gbest_acc": 45.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.626379,
+ "gbest_acc": 45.55,
+ "val_loss": 1.642554,
+ "val_acc": 44.6
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.617016,
+ "gbest_acc": 46.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.608258,
+ "gbest_acc": 46.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548058,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548058,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548058,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548058,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.51832,
+ "gbest_acc": 49.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.51832,
+ "gbest_acc": 49.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.51832,
+ "gbest_acc": 49.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.509292,
+ "gbest_acc": 50.4,
+ "val_loss": 1.520981,
+ "val_acc": 49.39
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.499409,
+ "gbest_acc": 50.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.496912,
+ "gbest_acc": 49.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.476928,
+ "gbest_acc": 51.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.475891,
+ "gbest_acc": 51.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.465416,
+ "gbest_acc": 51.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.457626,
+ "gbest_acc": 52.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.457626,
+ "gbest_acc": 52.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.457626,
+ "gbest_acc": 52.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.443585,
+ "gbest_acc": 53.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.435169,
+ "gbest_acc": 52.5,
+ "val_loss": 1.450692,
+ "val_acc": 52.98
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.435169,
+ "gbest_acc": 52.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.406087,
+ "gbest_acc": 54.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.402892,
+ "gbest_acc": 54.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.379921,
+ "gbest_acc": 51.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332886,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332886,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332886,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332886,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331518,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.277132,
+ "gbest_acc": 57.8,
+ "val_loss": 1.288821,
+ "val_acc": 57.61
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.277132,
+ "gbest_acc": 57.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.277132,
+ "gbest_acc": 57.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.273769,
+ "gbest_acc": 58.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.262137,
+ "gbest_acc": 58.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26008,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26008,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26008,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26008,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26008,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.253803,
+ "gbest_acc": 57.55,
+ "val_loss": 1.26665,
+ "val_acc": 57.74
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.249793,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.243862,
+ "gbest_acc": 58.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.24209,
+ "gbest_acc": 58.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.236166,
+ "gbest_acc": 59.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.228308,
+ "gbest_acc": 59.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.228308,
+ "gbest_acc": 59.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.226109,
+ "gbest_acc": 59.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.222782,
+ "gbest_acc": 58.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.221923,
+ "gbest_acc": 59.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.2132,
+ "gbest_acc": 60.0,
+ "val_loss": 1.228897,
+ "val_acc": 59.21
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.195836,
+ "gbest_acc": 59.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.188061,
+ "gbest_acc": 61.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.188061,
+ "gbest_acc": 61.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.184243,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.184243,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.18185,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.180844,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.17235,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.17235,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.16785,
+ "gbest_acc": 61.55,
+ "val_loss": 1.19235,
+ "val_acc": 60.48
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.159835,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.157449,
+ "gbest_acc": 62.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.147835,
+ "gbest_acc": 62.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146912,
+ "gbest_acc": 63.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.131573,
+ "gbest_acc": 63.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.120912,
+ "gbest_acc": 63.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.120912,
+ "gbest_acc": 63.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.118666,
+ "gbest_acc": 63.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.101176,
+ "gbest_acc": 64.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.097438,
+ "gbest_acc": 64.05,
+ "val_loss": 1.126786,
+ "val_acc": 63.18
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.097438,
+ "gbest_acc": 64.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.07454,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.072343,
+ "gbest_acc": 65.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.072343,
+ "gbest_acc": 65.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.069028,
+ "gbest_acc": 65.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.055623,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.049842,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.049842,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.044047,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.04235,
+ "gbest_acc": 66.75,
+ "val_loss": 1.074293,
+ "val_acc": 64.94
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.029091,
+ "gbest_acc": 66.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023243,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023243,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023243,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023243,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.017569,
+ "gbest_acc": 66.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.017569,
+ "gbest_acc": 66.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.008633,
+ "gbest_acc": 66.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.004002,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.00061,
+ "gbest_acc": 66.8,
+ "val_loss": 1.030409,
+ "val_acc": 66.14
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.00061,
+ "gbest_acc": 66.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.999347,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.999347,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.999347,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993094,
+ "gbest_acc": 66.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.986082,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.981956,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.981956,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.973175,
+ "gbest_acc": 67.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972542,
+ "gbest_acc": 67.45,
+ "val_loss": 0.995518,
+ "val_acc": 67.59
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.971742,
+ "gbest_acc": 67.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.966672,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.966672,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.959388,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.959143,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.956071,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.948034,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.941507,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.937224,
+ "gbest_acc": 68.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.929362,
+ "gbest_acc": 69.65,
+ "val_loss": 0.949647,
+ "val_acc": 69.34
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92441,
+ "gbest_acc": 69.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92441,
+ "gbest_acc": 69.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92441,
+ "gbest_acc": 69.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.922341,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.917089,
+ "gbest_acc": 70.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.907896,
+ "gbest_acc": 70.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.900849,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.900849,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.900849,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.897977,
+ "gbest_acc": 70.3,
+ "val_loss": 0.923239,
+ "val_acc": 69.82
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.896607,
+ "gbest_acc": 70.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.894509,
+ "gbest_acc": 70.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.891321,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.891321,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.891038,
+ "gbest_acc": 70.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.887064,
+ "gbest_acc": 71.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884475,
+ "gbest_acc": 71.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884475,
+ "gbest_acc": 71.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.879805,
+ "gbest_acc": 71.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87666,
+ "gbest_acc": 71.9,
+ "val_loss": 0.90151,
+ "val_acc": 70.93
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G5",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test sufficient bound expansion"
+ }
+ },
+ "G6": {
+ "config_id": "G6",
+ "gbest_loss": 0.961326,
+ "gbest_acc": 69.05,
+ "gbest_val_loss": 0.96129,
+ "gbest_val_acc": 69.56,
+ "val_selected_particle_idx": 12,
+ "val_selected_loss": 0.96129,
+ "val_selected_acc": 69.56,
+ "val_metrics": {
+ "accuracy": 69.56,
+ "nll": 0.96129,
+ "brier": 0.429042,
+ "ece": 0.06558,
+ "margin": 0.465525
+ },
+ "wall_time_sec": 6.7408,
+ "optimization_wall_time_sec": 6.554,
+ "validation_wall_time_sec": 0.1868,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 88,
+ "final_moment_steps": [
+ 31,
+ 46,
+ 47,
+ 118,
+ 13,
+ 16,
+ 41,
+ 42,
+ 41,
+ 76,
+ 160,
+ 28,
+ 3,
+ 11,
+ 43,
+ 59,
+ 14,
+ 56,
+ 8,
+ 107,
+ 4,
+ 36,
+ 17,
+ 41,
+ 34,
+ 17,
+ 31,
+ 88,
+ 4,
+ 83
+ ],
+ "pbest_update_counts": 2143,
+ "boundary_hits": 91538,
+ "boundary_occupancy": 0.002096,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.27561,
+ "position_radius": 18.448799,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.325288,
+ "gbest_acc": 7.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.30952,
+ "gbest_acc": 11.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.30333,
+ "gbest_acc": 12.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.27474,
+ "gbest_acc": 17.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.257845,
+ "gbest_acc": 14.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.206771,
+ "gbest_acc": 22.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.166269,
+ "gbest_acc": 25.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.166269,
+ "gbest_acc": 25.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.068628,
+ "gbest_acc": 31.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.035147,
+ "gbest_acc": 27.85,
+ "val_loss": 2.046996,
+ "val_acc": 27.34
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.026116,
+ "gbest_acc": 33.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.984777,
+ "gbest_acc": 30.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.908976,
+ "gbest_acc": 34.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.908976,
+ "gbest_acc": 34.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.907655,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.90281,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.899526,
+ "gbest_acc": 35.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.895408,
+ "gbest_acc": 34.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.873505,
+ "gbest_acc": 34.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.873505,
+ "gbest_acc": 34.7,
+ "val_loss": 1.885487,
+ "val_acc": 34.91
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.873505,
+ "gbest_acc": 34.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.866245,
+ "gbest_acc": 34.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.833964,
+ "gbest_acc": 36.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.817472,
+ "gbest_acc": 36.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.817472,
+ "gbest_acc": 36.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.810248,
+ "gbest_acc": 36.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.810248,
+ "gbest_acc": 36.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.809053,
+ "gbest_acc": 36.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.809053,
+ "gbest_acc": 36.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.799193,
+ "gbest_acc": 37.6,
+ "val_loss": 1.80777,
+ "val_acc": 37.76
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.79631,
+ "gbest_acc": 39.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.78926,
+ "gbest_acc": 37.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.770977,
+ "gbest_acc": 38.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.770977,
+ "gbest_acc": 38.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76754,
+ "gbest_acc": 39.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76754,
+ "gbest_acc": 39.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76754,
+ "gbest_acc": 39.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.754465,
+ "gbest_acc": 40.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.754465,
+ "gbest_acc": 40.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.736352,
+ "gbest_acc": 40.35,
+ "val_loss": 1.740964,
+ "val_acc": 39.54
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730599,
+ "gbest_acc": 38.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730599,
+ "gbest_acc": 38.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730599,
+ "gbest_acc": 38.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711387,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711387,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711387,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711387,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.68994,
+ "gbest_acc": 42.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.68994,
+ "gbest_acc": 42.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.68994,
+ "gbest_acc": 42.0,
+ "val_loss": 1.694976,
+ "val_acc": 43.17
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.68994,
+ "gbest_acc": 42.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.68994,
+ "gbest_acc": 42.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.67567,
+ "gbest_acc": 42.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.646899,
+ "gbest_acc": 43.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.646899,
+ "gbest_acc": 43.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.646899,
+ "gbest_acc": 43.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.641969,
+ "gbest_acc": 43.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.641969,
+ "gbest_acc": 43.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629627,
+ "gbest_acc": 44.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.621204,
+ "gbest_acc": 44.8,
+ "val_loss": 1.62915,
+ "val_acc": 45.81
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.619025,
+ "gbest_acc": 44.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.607883,
+ "gbest_acc": 44.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.595301,
+ "gbest_acc": 46.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581446,
+ "gbest_acc": 46.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581446,
+ "gbest_acc": 46.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.56116,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.56116,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5547,
+ "gbest_acc": 46.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5547,
+ "gbest_acc": 46.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.547316,
+ "gbest_acc": 45.8,
+ "val_loss": 1.560907,
+ "val_acc": 47.36
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.539633,
+ "gbest_acc": 47.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52906,
+ "gbest_acc": 47.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.521271,
+ "gbest_acc": 48.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.511641,
+ "gbest_acc": 49.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.501456,
+ "gbest_acc": 49.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.495384,
+ "gbest_acc": 50.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.495384,
+ "gbest_acc": 50.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.477692,
+ "gbest_acc": 50.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.465775,
+ "gbest_acc": 50.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.465775,
+ "gbest_acc": 50.5,
+ "val_loss": 1.487023,
+ "val_acc": 50.61
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.463173,
+ "gbest_acc": 50.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.428135,
+ "gbest_acc": 52.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.428135,
+ "gbest_acc": 52.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.416037,
+ "gbest_acc": 52.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.413407,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.405569,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.390931,
+ "gbest_acc": 53.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.372991,
+ "gbest_acc": 53.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.372991,
+ "gbest_acc": 53.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357691,
+ "gbest_acc": 54.05,
+ "val_loss": 1.370485,
+ "val_acc": 54.93
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357691,
+ "gbest_acc": 54.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357691,
+ "gbest_acc": 54.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.355001,
+ "gbest_acc": 54.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338486,
+ "gbest_acc": 56.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338486,
+ "gbest_acc": 56.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.333933,
+ "gbest_acc": 55.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.31521,
+ "gbest_acc": 57.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.308802,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.292441,
+ "gbest_acc": 57.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.292441,
+ "gbest_acc": 57.75,
+ "val_loss": 1.305631,
+ "val_acc": 58.03
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.287728,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.285697,
+ "gbest_acc": 58.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.276035,
+ "gbest_acc": 59.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.256802,
+ "gbest_acc": 60.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.256338,
+ "gbest_acc": 60.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.243438,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.243303,
+ "gbest_acc": 60.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.243303,
+ "gbest_acc": 60.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.232502,
+ "gbest_acc": 61.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.228855,
+ "gbest_acc": 60.95,
+ "val_loss": 1.23967,
+ "val_acc": 60.87
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.213689,
+ "gbest_acc": 61.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.213689,
+ "gbest_acc": 61.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.21292,
+ "gbest_acc": 61.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.212314,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199686,
+ "gbest_acc": 62.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.194835,
+ "gbest_acc": 62.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.190278,
+ "gbest_acc": 62.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.188638,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177123,
+ "gbest_acc": 62.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177123,
+ "gbest_acc": 62.5,
+ "val_loss": 1.190327,
+ "val_acc": 62.66
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.169856,
+ "gbest_acc": 62.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.160888,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.15864,
+ "gbest_acc": 63.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.15864,
+ "gbest_acc": 63.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.154944,
+ "gbest_acc": 63.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.149841,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.141024,
+ "gbest_acc": 64.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136587,
+ "gbest_acc": 62.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132175,
+ "gbest_acc": 63.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.124431,
+ "gbest_acc": 64.55,
+ "val_loss": 1.133461,
+ "val_acc": 64.36
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.119002,
+ "gbest_acc": 64.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.11873,
+ "gbest_acc": 64.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.107671,
+ "gbest_acc": 65.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.105437,
+ "gbest_acc": 64.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.092362,
+ "gbest_acc": 65.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.092362,
+ "gbest_acc": 65.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.087102,
+ "gbest_acc": 65.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.084745,
+ "gbest_acc": 65.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.083938,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.075225,
+ "gbest_acc": 65.95,
+ "val_loss": 1.080466,
+ "val_acc": 66.2
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.070469,
+ "gbest_acc": 65.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.070227,
+ "gbest_acc": 66.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.065267,
+ "gbest_acc": 65.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.054889,
+ "gbest_acc": 66.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.044873,
+ "gbest_acc": 68.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.039123,
+ "gbest_acc": 68.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.030557,
+ "gbest_acc": 67.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.019085,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.011961,
+ "gbest_acc": 67.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.011484,
+ "gbest_acc": 68.0,
+ "val_loss": 1.010008,
+ "val_acc": 68.36
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.998134,
+ "gbest_acc": 69.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993379,
+ "gbest_acc": 68.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.987521,
+ "gbest_acc": 69.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.98132,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972304,
+ "gbest_acc": 69.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972304,
+ "gbest_acc": 69.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972304,
+ "gbest_acc": 69.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.969385,
+ "gbest_acc": 69.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967466,
+ "gbest_acc": 68.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.961326,
+ "gbest_acc": 69.05,
+ "val_loss": 0.96129,
+ "val_acc": 69.56
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G6",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 1.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test broader normalized initialization"
+ }
+ },
+ "G7": {
+ "config_id": "G7",
+ "gbest_loss": 1.286895,
+ "gbest_acc": 59.85,
+ "gbest_val_loss": 1.291266,
+ "gbest_val_acc": 58.79,
+ "val_selected_particle_idx": 5,
+ "val_selected_loss": 1.291266,
+ "val_selected_acc": 58.79,
+ "val_metrics": {
+ "accuracy": 58.79,
+ "nll": 1.291266,
+ "brier": 0.58435,
+ "ece": 0.169163,
+ "margin": 0.234253
+ },
+ "wall_time_sec": 6.4273,
+ "optimization_wall_time_sec": 6.2459,
+ "validation_wall_time_sec": 0.1814,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160
+ ],
+ "pbest_update_counts": 2482,
+ "boundary_hits": 228313,
+ "boundary_occupancy": 0.005228,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.267674,
+ "position_radius": 16.999327,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.309139,
+ "gbest_acc": 7.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.299011,
+ "gbest_acc": 9.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.287127,
+ "gbest_acc": 11.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.27862,
+ "gbest_acc": 11.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.255058,
+ "gbest_acc": 14.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.23202,
+ "gbest_acc": 15.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.23202,
+ "gbest_acc": 15.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.227222,
+ "gbest_acc": 17.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.214962,
+ "gbest_acc": 22.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.201656,
+ "gbest_acc": 25.35,
+ "val_loss": 2.197669,
+ "val_acc": 26.38
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.175992,
+ "gbest_acc": 21.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.174001,
+ "gbest_acc": 24.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.171524,
+ "gbest_acc": 22.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.171524,
+ "gbest_acc": 22.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.16751,
+ "gbest_acc": 21.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.141776,
+ "gbest_acc": 24.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.141776,
+ "gbest_acc": 24.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.120553,
+ "gbest_acc": 25.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.118536,
+ "gbest_acc": 24.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.116341,
+ "gbest_acc": 28.7,
+ "val_loss": 2.103779,
+ "val_acc": 28.58
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.086713,
+ "gbest_acc": 28.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.086713,
+ "gbest_acc": 28.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.078963,
+ "gbest_acc": 30.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.061015,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.061015,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.042015,
+ "gbest_acc": 31.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.040004,
+ "gbest_acc": 32.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.028711,
+ "gbest_acc": 27.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.025341,
+ "gbest_acc": 31.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.998952,
+ "gbest_acc": 33.6,
+ "val_loss": 1.99407,
+ "val_acc": 33.57
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.998952,
+ "gbest_acc": 33.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.99236,
+ "gbest_acc": 36.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.99236,
+ "gbest_acc": 36.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.990788,
+ "gbest_acc": 33.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.977843,
+ "gbest_acc": 32.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.973256,
+ "gbest_acc": 30.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.961657,
+ "gbest_acc": 33.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.961657,
+ "gbest_acc": 33.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.961657,
+ "gbest_acc": 33.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.950446,
+ "gbest_acc": 35.1,
+ "val_loss": 1.952211,
+ "val_acc": 34.13
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.939352,
+ "gbest_acc": 33.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.917866,
+ "gbest_acc": 35.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.905276,
+ "gbest_acc": 36.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.900597,
+ "gbest_acc": 37.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.900597,
+ "gbest_acc": 37.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.884362,
+ "gbest_acc": 41.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.884362,
+ "gbest_acc": 41.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883041,
+ "gbest_acc": 40.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.870878,
+ "gbest_acc": 38.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.85983,
+ "gbest_acc": 39.1,
+ "val_loss": 1.855194,
+ "val_acc": 38.47
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.848652,
+ "gbest_acc": 39.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.845486,
+ "gbest_acc": 40.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.839194,
+ "gbest_acc": 39.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.834288,
+ "gbest_acc": 40.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.818126,
+ "gbest_acc": 41.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.818126,
+ "gbest_acc": 41.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.816245,
+ "gbest_acc": 41.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.812257,
+ "gbest_acc": 42.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.810906,
+ "gbest_acc": 43.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.807155,
+ "gbest_acc": 42.2,
+ "val_loss": 1.813947,
+ "val_acc": 41.75
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.801779,
+ "gbest_acc": 43.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.777376,
+ "gbest_acc": 44.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.775451,
+ "gbest_acc": 43.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76432,
+ "gbest_acc": 42.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76432,
+ "gbest_acc": 42.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76432,
+ "gbest_acc": 42.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.758181,
+ "gbest_acc": 44.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.758181,
+ "gbest_acc": 44.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.745974,
+ "gbest_acc": 46.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.745032,
+ "gbest_acc": 47.1,
+ "val_loss": 1.747376,
+ "val_acc": 46.71
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.735996,
+ "gbest_acc": 46.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.726349,
+ "gbest_acc": 47.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.726349,
+ "gbest_acc": 47.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.726349,
+ "gbest_acc": 47.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.709275,
+ "gbest_acc": 47.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.709275,
+ "gbest_acc": 47.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.689212,
+ "gbest_acc": 47.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.689212,
+ "gbest_acc": 47.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687616,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.682901,
+ "gbest_acc": 47.65,
+ "val_loss": 1.677802,
+ "val_acc": 48.27
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.682901,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.682901,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675636,
+ "gbest_acc": 48.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.66942,
+ "gbest_acc": 48.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.665965,
+ "gbest_acc": 48.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.654253,
+ "gbest_acc": 49.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.643053,
+ "gbest_acc": 50.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.643053,
+ "gbest_acc": 50.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.630918,
+ "gbest_acc": 50.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.625607,
+ "gbest_acc": 51.05,
+ "val_loss": 1.622408,
+ "val_acc": 50.7
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.605352,
+ "gbest_acc": 50.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.605352,
+ "gbest_acc": 50.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.589749,
+ "gbest_acc": 50.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.589749,
+ "gbest_acc": 50.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581419,
+ "gbest_acc": 52.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581419,
+ "gbest_acc": 52.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581419,
+ "gbest_acc": 52.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.570031,
+ "gbest_acc": 53.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.558124,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.551278,
+ "gbest_acc": 50.1,
+ "val_loss": 1.54449,
+ "val_acc": 50.36
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548868,
+ "gbest_acc": 51.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.544148,
+ "gbest_acc": 52.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.532144,
+ "gbest_acc": 52.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.527366,
+ "gbest_acc": 53.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.527366,
+ "gbest_acc": 53.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.525305,
+ "gbest_acc": 54.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.520576,
+ "gbest_acc": 54.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.514018,
+ "gbest_acc": 54.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.506088,
+ "gbest_acc": 55.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.505858,
+ "gbest_acc": 54.6,
+ "val_loss": 1.505211,
+ "val_acc": 54.28
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.501922,
+ "gbest_acc": 55.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.499061,
+ "gbest_acc": 54.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.495314,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.491583,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474219,
+ "gbest_acc": 56.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.470855,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.456732,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.455199,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.455199,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.455199,
+ "gbest_acc": 56.15,
+ "val_loss": 1.453086,
+ "val_acc": 55.69
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.450464,
+ "gbest_acc": 55.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.441264,
+ "gbest_acc": 56.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.438647,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.432057,
+ "gbest_acc": 55.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.424615,
+ "gbest_acc": 56.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.422398,
+ "gbest_acc": 55.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.418894,
+ "gbest_acc": 56.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.414879,
+ "gbest_acc": 56.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.410718,
+ "gbest_acc": 57.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.405867,
+ "gbest_acc": 56.55,
+ "val_loss": 1.407187,
+ "val_acc": 55.96
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.396443,
+ "gbest_acc": 57.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.385648,
+ "gbest_acc": 56.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.377888,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.369016,
+ "gbest_acc": 57.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.36734,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362107,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.360926,
+ "gbest_acc": 56.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.360926,
+ "gbest_acc": 56.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.360926,
+ "gbest_acc": 56.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.356624,
+ "gbest_acc": 57.7,
+ "val_loss": 1.363448,
+ "val_acc": 56.94
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.354778,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.353311,
+ "gbest_acc": 57.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.347267,
+ "gbest_acc": 57.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.340002,
+ "gbest_acc": 58.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.337986,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.336033,
+ "gbest_acc": 58.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331574,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.328634,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.324152,
+ "gbest_acc": 58.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.324152,
+ "gbest_acc": 58.6,
+ "val_loss": 1.330312,
+ "val_acc": 57.4
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.319941,
+ "gbest_acc": 59.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.319941,
+ "gbest_acc": 59.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.317319,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.317319,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.314964,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.311068,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.299587,
+ "gbest_acc": 61.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.297939,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.296547,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.286895,
+ "gbest_acc": 59.85,
+ "val_loss": 1.291266,
+ "val_acc": 58.79
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G7",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "independent",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate antithetic position coupling against G2"
+ }
+ },
+ "G8": {
+ "config_id": "G8",
+ "gbest_loss": 0.858659,
+ "gbest_acc": 73.15,
+ "val_selected_loss": 0.883557,
+ "val_selected_acc": 70.99,
+ "val_metrics": {
+ "accuracy": 70.99,
+ "nll": 0.883557,
+ "brier": 0.402781,
+ "ece": 0.025241,
+ "margin": 0.533326
+ },
+ "wall_time_sec": 8.7632,
+ "optimization_wall_time_sec": 8.4371,
+ "validation_wall_time_sec": 0.326,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 31,
+ "official_test_evaluations": 0,
+ "pbest_update_counts": 0,
+ "boundary_hits": 0,
+ "boundary_occupancy": 0.0,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.0,
+ "position_radius": 0.0,
+ "stage_histories": [],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G8",
+ "scale_type": "optimizer_default",
+ "init_position_mode": "independent",
+ "position_radius": 0.05,
+ "initial_velocity_radius": 0.05,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "retained semantic control (public Optimizer)"
+ }
+ }
+ },
+ "factor_deltas": {
+ "delta_scale_G1_vs_G0": {
+ "test_config": "G1",
+ "ref_config": "G0",
+ "nll_diff": 0.254487,
+ "acc_diff": -5.41,
+ "material": false,
+ "description": "global RMS scale vs per-tensor SD"
+ },
+ "delta_vel_G2_vs_G0": {
+ "test_config": "G2",
+ "ref_config": "G0",
+ "nll_diff": 0.112988,
+ "acc_diff": -7.01,
+ "material": false,
+ "description": "launch velocity U(-0.5,0.5) vs 0"
+ },
+ "delta_mut_G3_vs_G0": {
+ "test_config": "G3",
+ "ref_config": "G0",
+ "nll_diff": -0.052278,
+ "acc_diff": 0.34,
+ "material": true,
+ "description": "mutation 0.02 vs 0"
+ },
+ "delta_vel_mut_G4_vs_G2": {
+ "test_config": "G4",
+ "ref_config": "G2",
+ "nll_diff": -0.179825,
+ "acc_diff": 5.04,
+ "material": true,
+ "description": "mutation interaction given velocity"
+ },
+ "delta_bound_G5_vs_G4": {
+ "test_config": "G5",
+ "ref_config": "G4",
+ "nll_diff": -0.21477,
+ "acc_diff": 5.17,
+ "material": true,
+ "description": "bound box 6 vs 3"
+ },
+ "delta_radius_G6_vs_G5": {
+ "test_config": "G6",
+ "ref_config": "G5",
+ "nll_diff": 0.05978,
+ "acc_diff": -1.37,
+ "material": false,
+ "description": "initial position radius 1.5 vs 0.5"
+ },
+ "delta_init_G7_vs_G2": {
+ "test_config": "G7",
+ "ref_config": "G2",
+ "nll_diff": -0.004839,
+ "acc_diff": -1.93,
+ "material": false,
+ "description": "independent vs antithetic init"
+ },
+ "delta_bundle_G8_vs_best_norm": {
+ "test_config": "G8",
+ "ref_config": "G5",
+ "nll_diff": -0.017953,
+ "acc_diff": 0.06,
+ "material": false,
+ "description": "Optimizer G8 control vs best normalized (G5)"
+ }
+ },
+ "selected_for_confirm": [
+ "G0",
+ "G1",
+ "G8",
+ "G5",
+ "G6"
+ ]
+ },
+ "confirm_payload": {
+ "phase": "confirm",
+ "seeds": [
+ 101,
+ 102,
+ 103
+ ],
+ "swarm_size": 60,
+ "epochs": 420,
+ "selected_configs": [
+ "G0",
+ "G1",
+ "G8",
+ "G5",
+ "G6"
+ ],
+ "confirm_runs": {
+ "G0": [
+ {
+ "config_id": "G0",
+ "gbest_loss": 0.633802,
+ "gbest_acc": 82.2,
+ "gbest_val_loss": 0.685946,
+ "gbest_val_acc": 79.13,
+ "val_selected_particle_idx": 19,
+ "val_selected_loss": 0.685428,
+ "val_selected_acc": 79.09,
+ "val_metrics": {
+ "accuracy": 79.09,
+ "nll": 0.685428,
+ "brier": 0.316149,
+ "ece": 0.108594,
+ "margin": 0.53177
+ },
+ "wall_time_sec": 32.6173,
+ "optimization_wall_time_sec": 32.1964,
+ "validation_wall_time_sec": 0.4209,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420
+ ],
+ "pbest_update_counts": 12571,
+ "boundary_hits": 789018,
+ "boundary_occupancy": 0.003441,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.085821,
+ "position_radius": 5.465564,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.313677,
+ "gbest_acc": 8.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.301218,
+ "gbest_acc": 8.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.285447,
+ "gbest_acc": 10.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.272852,
+ "gbest_acc": 10.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.25676,
+ "gbest_acc": 15.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.235169,
+ "gbest_acc": 16.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.215387,
+ "gbest_acc": 17.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.195139,
+ "gbest_acc": 16.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.172303,
+ "gbest_acc": 17.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.143942,
+ "gbest_acc": 18.4,
+ "val_loss": 2.151907,
+ "val_acc": 17.89
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.104848,
+ "gbest_acc": 25.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.074167,
+ "gbest_acc": 28.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.047088,
+ "gbest_acc": 31.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.037421,
+ "gbest_acc": 31.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.020699,
+ "gbest_acc": 32.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.001263,
+ "gbest_acc": 31.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.987104,
+ "gbest_acc": 32.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.974485,
+ "gbest_acc": 34.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.95992,
+ "gbest_acc": 33.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.920345,
+ "gbest_acc": 35.7,
+ "val_loss": 1.935011,
+ "val_acc": 35.02
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.89665,
+ "gbest_acc": 34.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.865372,
+ "gbest_acc": 37.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.862488,
+ "gbest_acc": 36.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.840315,
+ "gbest_acc": 37.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.80913,
+ "gbest_acc": 41.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.805179,
+ "gbest_acc": 41.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.790193,
+ "gbest_acc": 41.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.778837,
+ "gbest_acc": 42.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.741537,
+ "gbest_acc": 40.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.723342,
+ "gbest_acc": 41.95,
+ "val_loss": 1.733494,
+ "val_acc": 42.38
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.723342,
+ "gbest_acc": 41.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.723342,
+ "gbest_acc": 41.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711093,
+ "gbest_acc": 44.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.710663,
+ "gbest_acc": 43.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.697524,
+ "gbest_acc": 47.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.695646,
+ "gbest_acc": 43.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675379,
+ "gbest_acc": 44.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675379,
+ "gbest_acc": 44.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675379,
+ "gbest_acc": 44.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675379,
+ "gbest_acc": 44.8,
+ "val_loss": 1.68309,
+ "val_acc": 45.19
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.663724,
+ "gbest_acc": 47.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.643251,
+ "gbest_acc": 47.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.638516,
+ "gbest_acc": 49.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.638516,
+ "gbest_acc": 49.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.638516,
+ "gbest_acc": 49.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.630599,
+ "gbest_acc": 49.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.62583,
+ "gbest_acc": 49.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.612362,
+ "gbest_acc": 49.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.607309,
+ "gbest_acc": 49.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597507,
+ "gbest_acc": 49.9,
+ "val_loss": 1.616313,
+ "val_acc": 49.21
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597507,
+ "gbest_acc": 49.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.589937,
+ "gbest_acc": 49.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585674,
+ "gbest_acc": 49.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585674,
+ "gbest_acc": 49.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581922,
+ "gbest_acc": 48.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.573043,
+ "gbest_acc": 50.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566594,
+ "gbest_acc": 50.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.560889,
+ "gbest_acc": 50.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.559694,
+ "gbest_acc": 51.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548401,
+ "gbest_acc": 50.6,
+ "val_loss": 1.562575,
+ "val_acc": 50.63
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.53328,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.524198,
+ "gbest_acc": 52.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.516219,
+ "gbest_acc": 52.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.503186,
+ "gbest_acc": 53.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497528,
+ "gbest_acc": 53.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497528,
+ "gbest_acc": 53.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.480586,
+ "gbest_acc": 54.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.480586,
+ "gbest_acc": 54.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.480586,
+ "gbest_acc": 54.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.473519,
+ "gbest_acc": 56.2,
+ "val_loss": 1.492842,
+ "val_acc": 54.67
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.46558,
+ "gbest_acc": 55.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.454535,
+ "gbest_acc": 57.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.450421,
+ "gbest_acc": 55.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.447857,
+ "gbest_acc": 54.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.447857,
+ "gbest_acc": 54.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.445136,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.434835,
+ "gbest_acc": 56.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.428301,
+ "gbest_acc": 54.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.42308,
+ "gbest_acc": 56.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.42308,
+ "gbest_acc": 56.95,
+ "val_loss": 1.43687,
+ "val_acc": 57.5
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.420767,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401707,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401707,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401707,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401707,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401707,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388961,
+ "gbest_acc": 57.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.379293,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.367219,
+ "gbest_acc": 57.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.365159,
+ "gbest_acc": 57.1,
+ "val_loss": 1.388078,
+ "val_acc": 56.46
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362132,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362132,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357241,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.352113,
+ "gbest_acc": 59.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.340415,
+ "gbest_acc": 60.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.339663,
+ "gbest_acc": 59.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.339663,
+ "gbest_acc": 59.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.339663,
+ "gbest_acc": 59.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.3197,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.3197,
+ "gbest_acc": 60.15,
+ "val_loss": 1.348133,
+ "val_acc": 58.58
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.307931,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.305451,
+ "gbest_acc": 61.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.295244,
+ "gbest_acc": 60.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.295244,
+ "gbest_acc": 60.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.289637,
+ "gbest_acc": 61.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.27937,
+ "gbest_acc": 61.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.278637,
+ "gbest_acc": 61.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.272169,
+ "gbest_acc": 60.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.256237,
+ "gbest_acc": 61.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.253315,
+ "gbest_acc": 61.15,
+ "val_loss": 1.285717,
+ "val_acc": 59.68
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.248137,
+ "gbest_acc": 61.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240221,
+ "gbest_acc": 61.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.233605,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.224596,
+ "gbest_acc": 63.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.222144,
+ "gbest_acc": 62.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.22183,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.211832,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.211832,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.211832,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.208542,
+ "gbest_acc": 62.35,
+ "val_loss": 1.233988,
+ "val_acc": 61.75
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.200153,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.192073,
+ "gbest_acc": 63.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.179771,
+ "gbest_acc": 64.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177873,
+ "gbest_acc": 64.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177608,
+ "gbest_acc": 63.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172675,
+ "gbest_acc": 62.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.169088,
+ "gbest_acc": 64.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.16326,
+ "gbest_acc": 64.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.153378,
+ "gbest_acc": 64.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.151271,
+ "gbest_acc": 64.05,
+ "val_loss": 1.1847,
+ "val_acc": 63.1
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.151271,
+ "gbest_acc": 64.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.150086,
+ "gbest_acc": 64.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146745,
+ "gbest_acc": 63.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146745,
+ "gbest_acc": 63.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146745,
+ "gbest_acc": 63.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146246,
+ "gbest_acc": 64.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.143007,
+ "gbest_acc": 64.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.140579,
+ "gbest_acc": 64.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.134806,
+ "gbest_acc": 64.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.124985,
+ "gbest_acc": 64.15,
+ "val_loss": 1.158869,
+ "val_acc": 63.8
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12497,
+ "gbest_acc": 64.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.119891,
+ "gbest_acc": 64.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.119891,
+ "gbest_acc": 64.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.115576,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.111309,
+ "gbest_acc": 64.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.101847,
+ "gbest_acc": 65.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.087386,
+ "gbest_acc": 65.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.073213,
+ "gbest_acc": 66.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.073213,
+ "gbest_acc": 66.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.073213,
+ "gbest_acc": 66.0,
+ "val_loss": 1.106823,
+ "val_acc": 65.53
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.071652,
+ "gbest_acc": 66.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.067931,
+ "gbest_acc": 66.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057524,
+ "gbest_acc": 67.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057524,
+ "gbest_acc": 67.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057524,
+ "gbest_acc": 67.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057524,
+ "gbest_acc": 67.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057063,
+ "gbest_acc": 67.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.052032,
+ "gbest_acc": 67.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.047287,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.040389,
+ "gbest_acc": 67.55,
+ "val_loss": 1.076705,
+ "val_acc": 66.59
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.027877,
+ "gbest_acc": 67.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.026191,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.026191,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023765,
+ "gbest_acc": 68.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.022337,
+ "gbest_acc": 67.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.018796,
+ "gbest_acc": 68.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.012783,
+ "gbest_acc": 67.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.011271,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.008019,
+ "gbest_acc": 68.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.004226,
+ "gbest_acc": 68.35,
+ "val_loss": 1.044486,
+ "val_acc": 67.05
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.004226,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.003238,
+ "gbest_acc": 68.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996652,
+ "gbest_acc": 68.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.994623,
+ "gbest_acc": 69.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993795,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.99346,
+ "gbest_acc": 69.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.989703,
+ "gbest_acc": 70.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.986472,
+ "gbest_acc": 70.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.986106,
+ "gbest_acc": 70.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.981587,
+ "gbest_acc": 70.5,
+ "val_loss": 1.023797,
+ "val_acc": 68.23
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.980155,
+ "gbest_acc": 70.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.979024,
+ "gbest_acc": 70.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.973919,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.96914,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.966885,
+ "gbest_acc": 70.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.96551,
+ "gbest_acc": 70.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.960373,
+ "gbest_acc": 70.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.960373,
+ "gbest_acc": 70.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.958307,
+ "gbest_acc": 70.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.955938,
+ "gbest_acc": 70.3,
+ "val_loss": 0.996693,
+ "val_acc": 68.86
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.952121,
+ "gbest_acc": 70.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.948942,
+ "gbest_acc": 70.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.945218,
+ "gbest_acc": 71.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.940691,
+ "gbest_acc": 71.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.938968,
+ "gbest_acc": 71.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.937444,
+ "gbest_acc": 72.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.935324,
+ "gbest_acc": 71.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.934009,
+ "gbest_acc": 71.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.932876,
+ "gbest_acc": 72.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.928683,
+ "gbest_acc": 73.6,
+ "val_loss": 0.969211,
+ "val_acc": 70.18
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.926372,
+ "gbest_acc": 72.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92564,
+ "gbest_acc": 72.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.921348,
+ "gbest_acc": 73.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.919276,
+ "gbest_acc": 72.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.913393,
+ "gbest_acc": 72.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.910771,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.910359,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.90482,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.90482,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.904574,
+ "gbest_acc": 74.0,
+ "val_loss": 0.947963,
+ "val_acc": 71.04
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.904119,
+ "gbest_acc": 73.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.899794,
+ "gbest_acc": 74.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.897842,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.894584,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.894572,
+ "gbest_acc": 74.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.894572,
+ "gbest_acc": 74.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.893878,
+ "gbest_acc": 74.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.893878,
+ "gbest_acc": 74.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.893878,
+ "gbest_acc": 74.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.892495,
+ "gbest_acc": 74.0,
+ "val_loss": 0.933069,
+ "val_acc": 71.41
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.887176,
+ "gbest_acc": 74.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884516,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884516,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882184,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882184,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882184,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.881056,
+ "gbest_acc": 74.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.879287,
+ "gbest_acc": 74.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.877143,
+ "gbest_acc": 74.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.877143,
+ "gbest_acc": 74.75,
+ "val_loss": 0.917577,
+ "val_acc": 72.08
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.876832,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.873053,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871684,
+ "gbest_acc": 74.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.868702,
+ "gbest_acc": 74.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.867797,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.865331,
+ "gbest_acc": 74.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.863834,
+ "gbest_acc": 75.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.863398,
+ "gbest_acc": 74.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.862939,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.861933,
+ "gbest_acc": 75.4,
+ "val_loss": 0.904187,
+ "val_acc": 72.68
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858527,
+ "gbest_acc": 75.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.857223,
+ "gbest_acc": 75.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.854032,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.853678,
+ "gbest_acc": 75.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.851331,
+ "gbest_acc": 75.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849171,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.8485,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.8485,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.84823,
+ "gbest_acc": 75.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.84823,
+ "gbest_acc": 75.45,
+ "val_loss": 0.886928,
+ "val_acc": 73.07
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.847355,
+ "gbest_acc": 76.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.844035,
+ "gbest_acc": 75.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.838745,
+ "gbest_acc": 75.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.838733,
+ "gbest_acc": 76.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.833459,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.829304,
+ "gbest_acc": 76.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.827331,
+ "gbest_acc": 76.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.824824,
+ "gbest_acc": 76.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.824332,
+ "gbest_acc": 77.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.824332,
+ "gbest_acc": 77.0,
+ "val_loss": 0.867163,
+ "val_acc": 73.95
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821352,
+ "gbest_acc": 76.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.819641,
+ "gbest_acc": 76.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.819641,
+ "gbest_acc": 76.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.818047,
+ "gbest_acc": 76.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.818047,
+ "gbest_acc": 76.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.816055,
+ "gbest_acc": 76.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.813629,
+ "gbest_acc": 76.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.813629,
+ "gbest_acc": 76.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.813395,
+ "gbest_acc": 76.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.810268,
+ "gbest_acc": 76.75,
+ "val_loss": 0.85342,
+ "val_acc": 74.08
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.80828,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.805127,
+ "gbest_acc": 77.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.8028,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.800013,
+ "gbest_acc": 76.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.800013,
+ "gbest_acc": 76.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.798141,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.79649,
+ "gbest_acc": 77.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.793463,
+ "gbest_acc": 77.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.786999,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.786999,
+ "gbest_acc": 77.55,
+ "val_loss": 0.832197,
+ "val_acc": 75.23
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.786595,
+ "gbest_acc": 77.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.785016,
+ "gbest_acc": 77.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.779988,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.777171,
+ "gbest_acc": 77.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.775904,
+ "gbest_acc": 78.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.775904,
+ "gbest_acc": 78.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.775482,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.775131,
+ "gbest_acc": 78.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.77508,
+ "gbest_acc": 77.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.774836,
+ "gbest_acc": 77.75,
+ "val_loss": 0.821588,
+ "val_acc": 75.2
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.773399,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.772679,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.772679,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.772679,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.767749,
+ "gbest_acc": 77.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.767014,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.767014,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.766901,
+ "gbest_acc": 78.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.764455,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.763743,
+ "gbest_acc": 78.4,
+ "val_loss": 0.808491,
+ "val_acc": 75.8
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.760634,
+ "gbest_acc": 78.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.760276,
+ "gbest_acc": 77.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.757206,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.756396,
+ "gbest_acc": 77.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.756039,
+ "gbest_acc": 78.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.756039,
+ "gbest_acc": 78.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.756039,
+ "gbest_acc": 78.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.75269,
+ "gbest_acc": 78.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.749742,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74739,
+ "gbest_acc": 78.55,
+ "val_loss": 0.793297,
+ "val_acc": 75.69
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.746408,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.746408,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.746408,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74427,
+ "gbest_acc": 78.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.742964,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.742964,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.742964,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.742118,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.739165,
+ "gbest_acc": 78.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.739165,
+ "gbest_acc": 78.85,
+ "val_loss": 0.787489,
+ "val_acc": 75.69
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.736559,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.733685,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.730842,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.729747,
+ "gbest_acc": 79.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.728268,
+ "gbest_acc": 79.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.728056,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727059,
+ "gbest_acc": 78.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725962,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725829,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725545,
+ "gbest_acc": 79.2,
+ "val_loss": 0.775614,
+ "val_acc": 75.89
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725545,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725545,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.723154,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.722193,
+ "gbest_acc": 78.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721605,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721605,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721605,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.720136,
+ "gbest_acc": 79.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.716562,
+ "gbest_acc": 79.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.714309,
+ "gbest_acc": 79.0,
+ "val_loss": 0.765318,
+ "val_acc": 76.34
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.712869,
+ "gbest_acc": 79.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.710136,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.70766,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706658,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.70536,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703141,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703141,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.702427,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.701408,
+ "gbest_acc": 79.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.699995,
+ "gbest_acc": 79.4,
+ "val_loss": 0.749855,
+ "val_acc": 76.57
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.699109,
+ "gbest_acc": 78.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.697691,
+ "gbest_acc": 80.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.69538,
+ "gbest_acc": 80.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693206,
+ "gbest_acc": 80.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693206,
+ "gbest_acc": 80.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693206,
+ "gbest_acc": 80.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.691544,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688623,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.686891,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.686891,
+ "gbest_acc": 79.65,
+ "val_loss": 0.741712,
+ "val_acc": 77.14
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.686552,
+ "gbest_acc": 80.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.68507,
+ "gbest_acc": 80.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.682927,
+ "gbest_acc": 80.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.682927,
+ "gbest_acc": 80.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.682927,
+ "gbest_acc": 80.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.682927,
+ "gbest_acc": 80.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.681609,
+ "gbest_acc": 80.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.68069,
+ "gbest_acc": 79.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.679846,
+ "gbest_acc": 80.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.679846,
+ "gbest_acc": 80.2,
+ "val_loss": 0.732237,
+ "val_acc": 77.26
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.679254,
+ "gbest_acc": 79.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.677559,
+ "gbest_acc": 80.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.676398,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.67517,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.673712,
+ "gbest_acc": 80.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.673712,
+ "gbest_acc": 80.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.672469,
+ "gbest_acc": 81.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.671465,
+ "gbest_acc": 80.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.670877,
+ "gbest_acc": 81.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.670162,
+ "gbest_acc": 80.95,
+ "val_loss": 0.722701,
+ "val_acc": 77.78
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.670006,
+ "gbest_acc": 80.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.670006,
+ "gbest_acc": 80.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.669412,
+ "gbest_acc": 80.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.667928,
+ "gbest_acc": 81.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.667696,
+ "gbest_acc": 81.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.666281,
+ "gbest_acc": 81.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.665572,
+ "gbest_acc": 81.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.663169,
+ "gbest_acc": 81.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.659419,
+ "gbest_acc": 81.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.658179,
+ "gbest_acc": 81.55,
+ "val_loss": 0.708292,
+ "val_acc": 78.31
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.657167,
+ "gbest_acc": 81.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.656215,
+ "gbest_acc": 81.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.656062,
+ "gbest_acc": 81.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.655312,
+ "gbest_acc": 81.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.654909,
+ "gbest_acc": 81.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.654149,
+ "gbest_acc": 81.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.653486,
+ "gbest_acc": 81.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.652089,
+ "gbest_acc": 81.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.650322,
+ "gbest_acc": 81.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.649704,
+ "gbest_acc": 81.9,
+ "val_loss": 0.699505,
+ "val_acc": 78.89
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.648684,
+ "gbest_acc": 81.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.647225,
+ "gbest_acc": 81.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.646646,
+ "gbest_acc": 81.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.646189,
+ "gbest_acc": 81.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.644603,
+ "gbest_acc": 81.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.643438,
+ "gbest_acc": 81.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.642023,
+ "gbest_acc": 81.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.641696,
+ "gbest_acc": 82.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.641355,
+ "gbest_acc": 81.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.640637,
+ "gbest_acc": 82.05,
+ "val_loss": 0.692683,
+ "val_acc": 79.02
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.63886,
+ "gbest_acc": 81.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.638838,
+ "gbest_acc": 82.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.637654,
+ "gbest_acc": 82.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.636092,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.636092,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.636092,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.635722,
+ "gbest_acc": 82.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.633802,
+ "gbest_acc": 82.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.633802,
+ "gbest_acc": 82.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.633802,
+ "gbest_acc": 82.2,
+ "val_loss": 0.685946,
+ "val_acc": 79.13
+ }
+ ],
+ "seed": 101,
+ "geometry_config": {
+ "config_id": "G0",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "exact V5 control"
+ }
+ },
+ {
+ "config_id": "G0",
+ "gbest_loss": 0.662536,
+ "gbest_acc": 82.1,
+ "gbest_val_loss": 0.699154,
+ "gbest_val_acc": 80.2,
+ "val_selected_particle_idx": 58,
+ "val_selected_loss": 0.699005,
+ "val_selected_acc": 80.18,
+ "val_metrics": {
+ "accuracy": 80.18,
+ "nll": 0.699005,
+ "brier": 0.311782,
+ "ece": 0.13376,
+ "margin": 0.51392
+ },
+ "wall_time_sec": 32.1224,
+ "optimization_wall_time_sec": 31.6984,
+ "validation_wall_time_sec": 0.424,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420
+ ],
+ "pbest_update_counts": 12350,
+ "boundary_hits": 705300,
+ "boundary_occupancy": 0.003076,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.060965,
+ "position_radius": 4.637939,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.314652,
+ "gbest_acc": 8.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.307074,
+ "gbest_acc": 8.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.297392,
+ "gbest_acc": 10.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.28717,
+ "gbest_acc": 10.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.273744,
+ "gbest_acc": 11.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.252855,
+ "gbest_acc": 15.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.243629,
+ "gbest_acc": 11.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.217047,
+ "gbest_acc": 15.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.183382,
+ "gbest_acc": 18.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.165299,
+ "gbest_acc": 21.35,
+ "val_loss": 2.163949,
+ "val_acc": 20.34
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.145566,
+ "gbest_acc": 19.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.127849,
+ "gbest_acc": 21.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.105398,
+ "gbest_acc": 21.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.086457,
+ "gbest_acc": 24.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.066531,
+ "gbest_acc": 22.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.035558,
+ "gbest_acc": 26.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.007202,
+ "gbest_acc": 27.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.965906,
+ "gbest_acc": 32.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.947275,
+ "gbest_acc": 34.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.940691,
+ "gbest_acc": 29.4,
+ "val_loss": 1.939283,
+ "val_acc": 30.04
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.918899,
+ "gbest_acc": 33.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.896375,
+ "gbest_acc": 31.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.878475,
+ "gbest_acc": 31.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.860492,
+ "gbest_acc": 35.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.851936,
+ "gbest_acc": 34.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.845591,
+ "gbest_acc": 38.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.845591,
+ "gbest_acc": 38.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.834479,
+ "gbest_acc": 35.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.833447,
+ "gbest_acc": 38.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.824804,
+ "gbest_acc": 34.85,
+ "val_loss": 1.825386,
+ "val_acc": 35.23
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.822195,
+ "gbest_acc": 36.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.804916,
+ "gbest_acc": 38.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.765187,
+ "gbest_acc": 38.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.765187,
+ "gbest_acc": 38.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.765187,
+ "gbest_acc": 38.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.746791,
+ "gbest_acc": 43.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.716333,
+ "gbest_acc": 45.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.716333,
+ "gbest_acc": 45.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.699198,
+ "gbest_acc": 47.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.699198,
+ "gbest_acc": 47.55,
+ "val_loss": 1.71272,
+ "val_acc": 46.72
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.681061,
+ "gbest_acc": 44.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.679152,
+ "gbest_acc": 44.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.679152,
+ "gbest_acc": 44.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.679152,
+ "gbest_acc": 44.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.669368,
+ "gbest_acc": 45.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.650319,
+ "gbest_acc": 44.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624876,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624876,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624876,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624876,
+ "gbest_acc": 46.5,
+ "val_loss": 1.638346,
+ "val_acc": 46.32
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624876,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.620738,
+ "gbest_acc": 46.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.614751,
+ "gbest_acc": 47.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.611005,
+ "gbest_acc": 46.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.611005,
+ "gbest_acc": 46.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.602792,
+ "gbest_acc": 46.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.602792,
+ "gbest_acc": 46.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.590975,
+ "gbest_acc": 47.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585729,
+ "gbest_acc": 46.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.567061,
+ "gbest_acc": 48.45,
+ "val_loss": 1.577566,
+ "val_acc": 48.83
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566092,
+ "gbest_acc": 47.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566092,
+ "gbest_acc": 47.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.565005,
+ "gbest_acc": 49.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.555475,
+ "gbest_acc": 49.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.542124,
+ "gbest_acc": 49.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.542124,
+ "gbest_acc": 49.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.542124,
+ "gbest_acc": 49.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.54153,
+ "gbest_acc": 50.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.526881,
+ "gbest_acc": 50.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.526881,
+ "gbest_acc": 50.25,
+ "val_loss": 1.536342,
+ "val_acc": 49.12
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.526881,
+ "gbest_acc": 50.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.526881,
+ "gbest_acc": 50.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5195,
+ "gbest_acc": 50.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.49862,
+ "gbest_acc": 52.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.496269,
+ "gbest_acc": 50.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.494356,
+ "gbest_acc": 51.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.490199,
+ "gbest_acc": 51.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.490199,
+ "gbest_acc": 51.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.481824,
+ "gbest_acc": 50.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.476317,
+ "gbest_acc": 51.35,
+ "val_loss": 1.488454,
+ "val_acc": 50.92
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.468632,
+ "gbest_acc": 51.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.442998,
+ "gbest_acc": 52.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.442998,
+ "gbest_acc": 52.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.442998,
+ "gbest_acc": 52.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.438832,
+ "gbest_acc": 51.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.438832,
+ "gbest_acc": 51.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.438832,
+ "gbest_acc": 51.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.435925,
+ "gbest_acc": 52.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.424146,
+ "gbest_acc": 52.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.415349,
+ "gbest_acc": 53.85,
+ "val_loss": 1.434949,
+ "val_acc": 53.3
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.411837,
+ "gbest_acc": 54.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.405917,
+ "gbest_acc": 54.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401856,
+ "gbest_acc": 55.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401856,
+ "gbest_acc": 55.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.391088,
+ "gbest_acc": 54.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.387467,
+ "gbest_acc": 54.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.374507,
+ "gbest_acc": 54.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.369182,
+ "gbest_acc": 54.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.369182,
+ "gbest_acc": 54.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357941,
+ "gbest_acc": 55.8,
+ "val_loss": 1.374407,
+ "val_acc": 54.86
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.354854,
+ "gbest_acc": 56.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.343088,
+ "gbest_acc": 56.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.343088,
+ "gbest_acc": 56.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.339319,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338408,
+ "gbest_acc": 55.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338408,
+ "gbest_acc": 55.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338408,
+ "gbest_acc": 55.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338025,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.326401,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.315668,
+ "gbest_acc": 56.3,
+ "val_loss": 1.338498,
+ "val_acc": 56.47
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.310245,
+ "gbest_acc": 56.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.30309,
+ "gbest_acc": 57.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.299424,
+ "gbest_acc": 57.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.291195,
+ "gbest_acc": 57.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279598,
+ "gbest_acc": 58.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279598,
+ "gbest_acc": 58.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.27879,
+ "gbest_acc": 58.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.268698,
+ "gbest_acc": 58.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.265512,
+ "gbest_acc": 59.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.265512,
+ "gbest_acc": 59.4,
+ "val_loss": 1.291361,
+ "val_acc": 58.53
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.263289,
+ "gbest_acc": 59.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.255685,
+ "gbest_acc": 60.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.254651,
+ "gbest_acc": 60.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.251733,
+ "gbest_acc": 60.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.249537,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.241428,
+ "gbest_acc": 60.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.236142,
+ "gbest_acc": 61.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.226473,
+ "gbest_acc": 61.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.221837,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.215822,
+ "gbest_acc": 62.1,
+ "val_loss": 1.238645,
+ "val_acc": 60.81
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.214657,
+ "gbest_acc": 61.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.214023,
+ "gbest_acc": 62.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.207905,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.195935,
+ "gbest_acc": 63.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.193055,
+ "gbest_acc": 63.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.192793,
+ "gbest_acc": 63.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.186548,
+ "gbest_acc": 63.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.185695,
+ "gbest_acc": 63.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.185376,
+ "gbest_acc": 63.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172993,
+ "gbest_acc": 63.75,
+ "val_loss": 1.191301,
+ "val_acc": 63.76
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172993,
+ "gbest_acc": 63.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172672,
+ "gbest_acc": 64.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.164976,
+ "gbest_acc": 65.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.164976,
+ "gbest_acc": 65.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.164976,
+ "gbest_acc": 65.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.160617,
+ "gbest_acc": 64.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.159,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.159,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.156369,
+ "gbest_acc": 64.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.14213,
+ "gbest_acc": 66.15,
+ "val_loss": 1.15642,
+ "val_acc": 65.11
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.139441,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.135301,
+ "gbest_acc": 66.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.135301,
+ "gbest_acc": 66.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.128614,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.123017,
+ "gbest_acc": 66.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.122288,
+ "gbest_acc": 67.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.118658,
+ "gbest_acc": 66.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.110606,
+ "gbest_acc": 66.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106726,
+ "gbest_acc": 67.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106726,
+ "gbest_acc": 67.15,
+ "val_loss": 1.123954,
+ "val_acc": 67.04
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.104495,
+ "gbest_acc": 67.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.10228,
+ "gbest_acc": 67.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.095114,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.089828,
+ "gbest_acc": 67.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.085364,
+ "gbest_acc": 67.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.082867,
+ "gbest_acc": 67.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.081901,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.080668,
+ "gbest_acc": 66.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.074919,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.074383,
+ "gbest_acc": 67.45,
+ "val_loss": 1.097346,
+ "val_acc": 66.86
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.069487,
+ "gbest_acc": 68.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.06257,
+ "gbest_acc": 67.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.056192,
+ "gbest_acc": 69.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.055899,
+ "gbest_acc": 69.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.055899,
+ "gbest_acc": 69.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.055899,
+ "gbest_acc": 69.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.05343,
+ "gbest_acc": 68.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.052246,
+ "gbest_acc": 69.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.052246,
+ "gbest_acc": 69.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.051466,
+ "gbest_acc": 68.35,
+ "val_loss": 1.074637,
+ "val_acc": 67.9
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.042926,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.040834,
+ "gbest_acc": 69.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.036938,
+ "gbest_acc": 69.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.032962,
+ "gbest_acc": 69.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.028109,
+ "gbest_acc": 70.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.021494,
+ "gbest_acc": 69.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.019423,
+ "gbest_acc": 69.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.012842,
+ "gbest_acc": 69.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.010593,
+ "gbest_acc": 70.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.010593,
+ "gbest_acc": 70.45,
+ "val_loss": 1.033864,
+ "val_acc": 69.73
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.010593,
+ "gbest_acc": 70.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.005359,
+ "gbest_acc": 70.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.004749,
+ "gbest_acc": 70.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.000908,
+ "gbest_acc": 71.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996608,
+ "gbest_acc": 71.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996608,
+ "gbest_acc": 71.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996608,
+ "gbest_acc": 71.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996056,
+ "gbest_acc": 71.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.994229,
+ "gbest_acc": 71.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993368,
+ "gbest_acc": 71.25,
+ "val_loss": 1.020133,
+ "val_acc": 69.42
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990039,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.987092,
+ "gbest_acc": 71.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.984221,
+ "gbest_acc": 71.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.982294,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.979657,
+ "gbest_acc": 71.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.978865,
+ "gbest_acc": 72.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974484,
+ "gbest_acc": 71.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.973513,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.973513,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.973513,
+ "gbest_acc": 72.45,
+ "val_loss": 0.999158,
+ "val_acc": 70.61
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.969168,
+ "gbest_acc": 73.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.966634,
+ "gbest_acc": 72.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.965794,
+ "gbest_acc": 72.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.96496,
+ "gbest_acc": 72.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.963513,
+ "gbest_acc": 71.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.960019,
+ "gbest_acc": 72.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.959203,
+ "gbest_acc": 72.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.957585,
+ "gbest_acc": 72.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.956074,
+ "gbest_acc": 73.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.956028,
+ "gbest_acc": 73.05,
+ "val_loss": 0.983875,
+ "val_acc": 71.74
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.953274,
+ "gbest_acc": 72.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.95108,
+ "gbest_acc": 72.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.948609,
+ "gbest_acc": 73.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.945673,
+ "gbest_acc": 73.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.939635,
+ "gbest_acc": 73.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.936792,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.936792,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.936792,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.93568,
+ "gbest_acc": 73.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.934299,
+ "gbest_acc": 74.15,
+ "val_loss": 0.961084,
+ "val_acc": 72.83
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.930508,
+ "gbest_acc": 73.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92805,
+ "gbest_acc": 74.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.926893,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.925479,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.922378,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.918581,
+ "gbest_acc": 74.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.918581,
+ "gbest_acc": 74.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.918581,
+ "gbest_acc": 74.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.91821,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.914648,
+ "gbest_acc": 73.7,
+ "val_loss": 0.944708,
+ "val_acc": 72.32
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.913586,
+ "gbest_acc": 73.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.912721,
+ "gbest_acc": 73.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.912721,
+ "gbest_acc": 73.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.909991,
+ "gbest_acc": 74.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.909991,
+ "gbest_acc": 74.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.906846,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.90678,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.903498,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.902915,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.901159,
+ "gbest_acc": 74.7,
+ "val_loss": 0.93257,
+ "val_acc": 72.58
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.899628,
+ "gbest_acc": 74.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.898525,
+ "gbest_acc": 74.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.896479,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.896479,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.896479,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.895774,
+ "gbest_acc": 74.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.894581,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.894136,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.890367,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.890367,
+ "gbest_acc": 75.15,
+ "val_loss": 0.917824,
+ "val_acc": 73.49
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.888981,
+ "gbest_acc": 74.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.88733,
+ "gbest_acc": 75.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.883378,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882718,
+ "gbest_acc": 75.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.88116,
+ "gbest_acc": 75.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.880844,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87957,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.877473,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875663,
+ "gbest_acc": 75.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875271,
+ "gbest_acc": 75.75,
+ "val_loss": 0.901807,
+ "val_acc": 73.68
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.868771,
+ "gbest_acc": 75.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.867293,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.866932,
+ "gbest_acc": 75.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.862862,
+ "gbest_acc": 76.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.860619,
+ "gbest_acc": 76.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.859334,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858821,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858821,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858204,
+ "gbest_acc": 76.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.85445,
+ "gbest_acc": 76.2,
+ "val_loss": 0.884266,
+ "val_acc": 74.7
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.853464,
+ "gbest_acc": 76.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.851202,
+ "gbest_acc": 76.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.850305,
+ "gbest_acc": 76.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.850101,
+ "gbest_acc": 77.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849514,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.847176,
+ "gbest_acc": 76.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.844499,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.844499,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.842627,
+ "gbest_acc": 76.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840578,
+ "gbest_acc": 77.45,
+ "val_loss": 0.865736,
+ "val_acc": 75.26
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840227,
+ "gbest_acc": 77.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.833332,
+ "gbest_acc": 77.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.831382,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.830377,
+ "gbest_acc": 77.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.830377,
+ "gbest_acc": 77.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.829683,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.828258,
+ "gbest_acc": 77.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.82629,
+ "gbest_acc": 76.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.823779,
+ "gbest_acc": 76.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821202,
+ "gbest_acc": 76.3,
+ "val_loss": 0.851103,
+ "val_acc": 74.87
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.816807,
+ "gbest_acc": 77.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.816807,
+ "gbest_acc": 77.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.816122,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.814015,
+ "gbest_acc": 77.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.812348,
+ "gbest_acc": 77.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.812348,
+ "gbest_acc": 77.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809264,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.806157,
+ "gbest_acc": 77.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.805587,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.802893,
+ "gbest_acc": 77.65,
+ "val_loss": 0.831145,
+ "val_acc": 75.7
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.80167,
+ "gbest_acc": 77.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.800298,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.797568,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.795933,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.795933,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.793618,
+ "gbest_acc": 77.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.791958,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.785689,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.781742,
+ "gbest_acc": 77.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.780385,
+ "gbest_acc": 78.65,
+ "val_loss": 0.810763,
+ "val_acc": 76.79
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.778438,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.778438,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.777431,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.775729,
+ "gbest_acc": 78.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.773803,
+ "gbest_acc": 78.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.769443,
+ "gbest_acc": 78.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.76888,
+ "gbest_acc": 78.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.766407,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.764332,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.762249,
+ "gbest_acc": 78.5,
+ "val_loss": 0.795576,
+ "val_acc": 76.77
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.762249,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.760729,
+ "gbest_acc": 78.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.759943,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.759739,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.759739,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.759568,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.755642,
+ "gbest_acc": 78.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.753388,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.75159,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.747497,
+ "gbest_acc": 78.6,
+ "val_loss": 0.778006,
+ "val_acc": 77.23
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74644,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74264,
+ "gbest_acc": 79.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74264,
+ "gbest_acc": 79.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.740747,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.739201,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.737092,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.733109,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.733109,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.732827,
+ "gbest_acc": 79.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.732127,
+ "gbest_acc": 79.7,
+ "val_loss": 0.766514,
+ "val_acc": 77.67
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.732075,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.729802,
+ "gbest_acc": 79.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725803,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725803,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725803,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.723323,
+ "gbest_acc": 80.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.723068,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.7216,
+ "gbest_acc": 80.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.7216,
+ "gbest_acc": 80.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.719491,
+ "gbest_acc": 80.3,
+ "val_loss": 0.754467,
+ "val_acc": 78.53
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.718292,
+ "gbest_acc": 80.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.714285,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.714285,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.714285,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.71375,
+ "gbest_acc": 80.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.712532,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.709635,
+ "gbest_acc": 79.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.709511,
+ "gbest_acc": 80.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.70877,
+ "gbest_acc": 80.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.70877,
+ "gbest_acc": 80.05,
+ "val_loss": 0.741437,
+ "val_acc": 78.82
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.70877,
+ "gbest_acc": 80.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706193,
+ "gbest_acc": 81.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706053,
+ "gbest_acc": 80.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705478,
+ "gbest_acc": 80.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703933,
+ "gbest_acc": 80.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703385,
+ "gbest_acc": 80.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.701733,
+ "gbest_acc": 80.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.699976,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.699976,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.699715,
+ "gbest_acc": 80.75,
+ "val_loss": 0.733157,
+ "val_acc": 79.01
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.697988,
+ "gbest_acc": 80.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.695566,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.694213,
+ "gbest_acc": 80.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693346,
+ "gbest_acc": 81.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.690646,
+ "gbest_acc": 81.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688917,
+ "gbest_acc": 81.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.687429,
+ "gbest_acc": 80.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.685612,
+ "gbest_acc": 80.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.685612,
+ "gbest_acc": 80.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.685363,
+ "gbest_acc": 81.1,
+ "val_loss": 0.721951,
+ "val_acc": 79.49
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.684828,
+ "gbest_acc": 81.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.683802,
+ "gbest_acc": 81.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.683277,
+ "gbest_acc": 81.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.681569,
+ "gbest_acc": 81.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.681569,
+ "gbest_acc": 81.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.681569,
+ "gbest_acc": 81.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.681569,
+ "gbest_acc": 81.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.68048,
+ "gbest_acc": 81.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.679738,
+ "gbest_acc": 81.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.679535,
+ "gbest_acc": 81.75,
+ "val_loss": 0.717119,
+ "val_acc": 79.57
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.677953,
+ "gbest_acc": 81.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.677541,
+ "gbest_acc": 81.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.675877,
+ "gbest_acc": 81.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.674916,
+ "gbest_acc": 81.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.674443,
+ "gbest_acc": 81.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.674443,
+ "gbest_acc": 81.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.672832,
+ "gbest_acc": 81.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.671292,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.671292,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.670718,
+ "gbest_acc": 82.05,
+ "val_loss": 0.706413,
+ "val_acc": 79.93
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.669937,
+ "gbest_acc": 81.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.667854,
+ "gbest_acc": 82.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.667163,
+ "gbest_acc": 81.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.6653,
+ "gbest_acc": 82.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.663808,
+ "gbest_acc": 82.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.663808,
+ "gbest_acc": 82.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.663808,
+ "gbest_acc": 82.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.662975,
+ "gbest_acc": 82.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.662536,
+ "gbest_acc": 82.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.662536,
+ "gbest_acc": 82.1,
+ "val_loss": 0.699154,
+ "val_acc": 80.2
+ }
+ ],
+ "seed": 102,
+ "geometry_config": {
+ "config_id": "G0",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "exact V5 control"
+ }
+ },
+ {
+ "config_id": "G0",
+ "gbest_loss": 0.649193,
+ "gbest_acc": 81.1,
+ "gbest_val_loss": 0.684629,
+ "gbest_val_acc": 79.31,
+ "val_selected_particle_idx": 29,
+ "val_selected_loss": 0.684629,
+ "val_selected_acc": 79.31,
+ "val_metrics": {
+ "accuracy": 79.31,
+ "nll": 0.684629,
+ "brier": 0.314848,
+ "ece": 0.116395,
+ "margin": 0.527051
+ },
+ "wall_time_sec": 30.8166,
+ "optimization_wall_time_sec": 30.4118,
+ "validation_wall_time_sec": 0.4047,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420
+ ],
+ "pbest_update_counts": 12409,
+ "boundary_hits": 752865,
+ "boundary_occupancy": 0.003284,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.141813,
+ "position_radius": 9.09326,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.306736,
+ "gbest_acc": 7.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.301095,
+ "gbest_acc": 9.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.285218,
+ "gbest_acc": 10.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.272207,
+ "gbest_acc": 13.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.258712,
+ "gbest_acc": 11.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.237577,
+ "gbest_acc": 11.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.219055,
+ "gbest_acc": 17.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.190786,
+ "gbest_acc": 19.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.165014,
+ "gbest_acc": 20.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.1444,
+ "gbest_acc": 21.4,
+ "val_loss": 2.151267,
+ "val_acc": 22.0
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.133009,
+ "gbest_acc": 25.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.124876,
+ "gbest_acc": 25.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.123546,
+ "gbest_acc": 29.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.120491,
+ "gbest_acc": 26.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.092338,
+ "gbest_acc": 27.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.070742,
+ "gbest_acc": 28.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.055494,
+ "gbest_acc": 29.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.050444,
+ "gbest_acc": 28.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.03032,
+ "gbest_acc": 29.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.019969,
+ "gbest_acc": 25.95,
+ "val_loss": 2.015333,
+ "val_acc": 26.91
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.98332,
+ "gbest_acc": 31.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.981001,
+ "gbest_acc": 33.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.953625,
+ "gbest_acc": 36.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.92213,
+ "gbest_acc": 37.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.92213,
+ "gbest_acc": 37.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.899446,
+ "gbest_acc": 36.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.881171,
+ "gbest_acc": 37.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.872066,
+ "gbest_acc": 38.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.872066,
+ "gbest_acc": 38.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.865757,
+ "gbest_acc": 37.15,
+ "val_loss": 1.862944,
+ "val_acc": 38.96
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.864147,
+ "gbest_acc": 34.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.850855,
+ "gbest_acc": 35.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.843205,
+ "gbest_acc": 37.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.832204,
+ "gbest_acc": 40.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.812147,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.790389,
+ "gbest_acc": 43.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.769716,
+ "gbest_acc": 40.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.736351,
+ "gbest_acc": 45.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.736351,
+ "gbest_acc": 45.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.736351,
+ "gbest_acc": 45.75,
+ "val_loss": 1.745945,
+ "val_acc": 45.51
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.728964,
+ "gbest_acc": 43.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.713552,
+ "gbest_acc": 42.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.710278,
+ "gbest_acc": 44.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.695851,
+ "gbest_acc": 44.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.684052,
+ "gbest_acc": 44.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.669037,
+ "gbest_acc": 45.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.648473,
+ "gbest_acc": 45.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.63566,
+ "gbest_acc": 45.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624056,
+ "gbest_acc": 46.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624056,
+ "gbest_acc": 46.95,
+ "val_loss": 1.63277,
+ "val_acc": 47.25
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.61576,
+ "gbest_acc": 48.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.60888,
+ "gbest_acc": 49.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.593466,
+ "gbest_acc": 49.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.574614,
+ "gbest_acc": 51.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.572293,
+ "gbest_acc": 49.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.572293,
+ "gbest_acc": 49.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.571663,
+ "gbest_acc": 50.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.567876,
+ "gbest_acc": 49.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.567876,
+ "gbest_acc": 49.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.564345,
+ "gbest_acc": 50.7,
+ "val_loss": 1.569299,
+ "val_acc": 50.65
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.546467,
+ "gbest_acc": 52.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.546467,
+ "gbest_acc": 52.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.544715,
+ "gbest_acc": 51.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.541698,
+ "gbest_acc": 53.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.529722,
+ "gbest_acc": 52.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.529722,
+ "gbest_acc": 52.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.520475,
+ "gbest_acc": 54.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.513356,
+ "gbest_acc": 51.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.511238,
+ "gbest_acc": 51.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.505921,
+ "gbest_acc": 53.9,
+ "val_loss": 1.509124,
+ "val_acc": 54.16
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.505921,
+ "gbest_acc": 53.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.489987,
+ "gbest_acc": 53.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.489987,
+ "gbest_acc": 53.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.484597,
+ "gbest_acc": 53.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.475171,
+ "gbest_acc": 54.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.468384,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.468384,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.468384,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.459432,
+ "gbest_acc": 53.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.450613,
+ "gbest_acc": 55.9,
+ "val_loss": 1.457016,
+ "val_acc": 55.1
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.441139,
+ "gbest_acc": 56.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.441139,
+ "gbest_acc": 56.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.43605,
+ "gbest_acc": 54.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.432794,
+ "gbest_acc": 56.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.432794,
+ "gbest_acc": 56.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.428505,
+ "gbest_acc": 56.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.428505,
+ "gbest_acc": 56.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.428505,
+ "gbest_acc": 56.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.420489,
+ "gbest_acc": 56.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.403591,
+ "gbest_acc": 55.9,
+ "val_loss": 1.410683,
+ "val_acc": 56.28
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.392963,
+ "gbest_acc": 57.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.392666,
+ "gbest_acc": 56.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.391011,
+ "gbest_acc": 58.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.384967,
+ "gbest_acc": 56.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.384967,
+ "gbest_acc": 56.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.384136,
+ "gbest_acc": 56.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.384136,
+ "gbest_acc": 56.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.377499,
+ "gbest_acc": 56.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.377499,
+ "gbest_acc": 56.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.376609,
+ "gbest_acc": 57.5,
+ "val_loss": 1.381019,
+ "val_acc": 57.66
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.361736,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.361736,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.361736,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.361736,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.345358,
+ "gbest_acc": 58.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.341193,
+ "gbest_acc": 57.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.341193,
+ "gbest_acc": 57.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.335249,
+ "gbest_acc": 57.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331691,
+ "gbest_acc": 58.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331691,
+ "gbest_acc": 58.1,
+ "val_loss": 1.324126,
+ "val_acc": 58.5
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.325926,
+ "gbest_acc": 58.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.312999,
+ "gbest_acc": 59.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.312842,
+ "gbest_acc": 59.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.312842,
+ "gbest_acc": 59.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.305198,
+ "gbest_acc": 60.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.302572,
+ "gbest_acc": 59.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.302018,
+ "gbest_acc": 60.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.302018,
+ "gbest_acc": 60.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.302018,
+ "gbest_acc": 60.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.295283,
+ "gbest_acc": 60.25,
+ "val_loss": 1.2915,
+ "val_acc": 59.91
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.28276,
+ "gbest_acc": 59.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.275106,
+ "gbest_acc": 59.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.2678,
+ "gbest_acc": 60.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26388,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.257533,
+ "gbest_acc": 59.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.257533,
+ "gbest_acc": 59.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.255258,
+ "gbest_acc": 61.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.250099,
+ "gbest_acc": 61.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.244453,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.236681,
+ "gbest_acc": 61.25,
+ "val_loss": 1.238899,
+ "val_acc": 60.76
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.232377,
+ "gbest_acc": 60.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.21781,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.212491,
+ "gbest_acc": 62.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.197734,
+ "gbest_acc": 63.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.197734,
+ "gbest_acc": 63.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.197734,
+ "gbest_acc": 63.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.194925,
+ "gbest_acc": 64.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.191174,
+ "gbest_acc": 63.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.18202,
+ "gbest_acc": 63.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172453,
+ "gbest_acc": 63.3,
+ "val_loss": 1.171373,
+ "val_acc": 63.44
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.165386,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.163869,
+ "gbest_acc": 63.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.155356,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.152931,
+ "gbest_acc": 64.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.135248,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.135248,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.135248,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.135248,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.133099,
+ "gbest_acc": 65.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.117737,
+ "gbest_acc": 67.2,
+ "val_loss": 1.119449,
+ "val_acc": 66.56
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.117737,
+ "gbest_acc": 67.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.116449,
+ "gbest_acc": 66.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.113959,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106013,
+ "gbest_acc": 65.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.096282,
+ "gbest_acc": 67.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.090645,
+ "gbest_acc": 67.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.087364,
+ "gbest_acc": 66.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.087364,
+ "gbest_acc": 66.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.077697,
+ "gbest_acc": 66.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.07466,
+ "gbest_acc": 66.6,
+ "val_loss": 1.08091,
+ "val_acc": 66.93
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.07466,
+ "gbest_acc": 66.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.066785,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.06637,
+ "gbest_acc": 67.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.062913,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.062913,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.061092,
+ "gbest_acc": 67.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057908,
+ "gbest_acc": 67.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057908,
+ "gbest_acc": 67.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.054054,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.051232,
+ "gbest_acc": 67.75,
+ "val_loss": 1.058238,
+ "val_acc": 67.91
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.046829,
+ "gbest_acc": 67.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.043936,
+ "gbest_acc": 67.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.04053,
+ "gbest_acc": 68.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.036955,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.0325,
+ "gbest_acc": 69.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.030122,
+ "gbest_acc": 68.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.030122,
+ "gbest_acc": 68.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.030122,
+ "gbest_acc": 68.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.030122,
+ "gbest_acc": 68.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023272,
+ "gbest_acc": 68.95,
+ "val_loss": 1.032547,
+ "val_acc": 69.81
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.019122,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.014617,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.006986,
+ "gbest_acc": 69.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.00455,
+ "gbest_acc": 70.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.002736,
+ "gbest_acc": 70.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.002736,
+ "gbest_acc": 70.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.002736,
+ "gbest_acc": 70.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996614,
+ "gbest_acc": 70.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996614,
+ "gbest_acc": 70.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.995444,
+ "gbest_acc": 71.15,
+ "val_loss": 1.007711,
+ "val_acc": 70.33
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993558,
+ "gbest_acc": 70.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.991494,
+ "gbest_acc": 70.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990618,
+ "gbest_acc": 70.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.988436,
+ "gbest_acc": 70.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.985452,
+ "gbest_acc": 71.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.983675,
+ "gbest_acc": 71.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.980629,
+ "gbest_acc": 71.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.980629,
+ "gbest_acc": 71.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.980629,
+ "gbest_acc": 71.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.977708,
+ "gbest_acc": 70.85,
+ "val_loss": 0.989304,
+ "val_acc": 70.38
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.977113,
+ "gbest_acc": 70.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972697,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972697,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.971173,
+ "gbest_acc": 70.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967602,
+ "gbest_acc": 71.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967602,
+ "gbest_acc": 71.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.962197,
+ "gbest_acc": 70.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.960478,
+ "gbest_acc": 71.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.956993,
+ "gbest_acc": 72.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.955682,
+ "gbest_acc": 71.35,
+ "val_loss": 0.969941,
+ "val_acc": 70.51
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.953295,
+ "gbest_acc": 72.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.949542,
+ "gbest_acc": 71.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.947368,
+ "gbest_acc": 72.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.947147,
+ "gbest_acc": 72.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.944569,
+ "gbest_acc": 72.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.944569,
+ "gbest_acc": 72.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.942983,
+ "gbest_acc": 72.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.942983,
+ "gbest_acc": 72.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.940003,
+ "gbest_acc": 72.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.938552,
+ "gbest_acc": 72.8,
+ "val_loss": 0.958855,
+ "val_acc": 71.23
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.938552,
+ "gbest_acc": 72.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.937258,
+ "gbest_acc": 72.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.934794,
+ "gbest_acc": 72.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.929854,
+ "gbest_acc": 72.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.929141,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.923239,
+ "gbest_acc": 73.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.922582,
+ "gbest_acc": 72.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.919944,
+ "gbest_acc": 73.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.916955,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.915314,
+ "gbest_acc": 73.75,
+ "val_loss": 0.936178,
+ "val_acc": 72.09
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.915158,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.912604,
+ "gbest_acc": 72.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.911354,
+ "gbest_acc": 72.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.909109,
+ "gbest_acc": 73.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.908928,
+ "gbest_acc": 73.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.906937,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.903967,
+ "gbest_acc": 73.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.901335,
+ "gbest_acc": 73.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.89987,
+ "gbest_acc": 74.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.899011,
+ "gbest_acc": 74.2,
+ "val_loss": 0.922501,
+ "val_acc": 72.83
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.894676,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.891424,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.889795,
+ "gbest_acc": 73.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.889795,
+ "gbest_acc": 73.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.889795,
+ "gbest_acc": 73.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.887789,
+ "gbest_acc": 73.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.88383,
+ "gbest_acc": 73.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882379,
+ "gbest_acc": 74.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882379,
+ "gbest_acc": 74.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882379,
+ "gbest_acc": 74.05,
+ "val_loss": 0.907094,
+ "val_acc": 72.52
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.88169,
+ "gbest_acc": 74.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.88058,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.879075,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875328,
+ "gbest_acc": 73.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.874951,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.872983,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871795,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.868419,
+ "gbest_acc": 74.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.866418,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.863975,
+ "gbest_acc": 73.9,
+ "val_loss": 0.885884,
+ "val_acc": 73.17
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.860003,
+ "gbest_acc": 74.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.857904,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.855202,
+ "gbest_acc": 74.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.85461,
+ "gbest_acc": 74.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.854425,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.854425,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.854425,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.854425,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.85248,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.850354,
+ "gbest_acc": 74.15,
+ "val_loss": 0.87347,
+ "val_acc": 73.51
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.845735,
+ "gbest_acc": 74.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.844941,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.842368,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.842368,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.842368,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840299,
+ "gbest_acc": 75.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840299,
+ "gbest_acc": 75.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840167,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.837389,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.836726,
+ "gbest_acc": 74.9,
+ "val_loss": 0.861769,
+ "val_acc": 73.56
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.835198,
+ "gbest_acc": 74.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.831905,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.829801,
+ "gbest_acc": 75.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.828782,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.826812,
+ "gbest_acc": 76.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.824786,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.824786,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.822587,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.818785,
+ "gbest_acc": 75.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.816681,
+ "gbest_acc": 75.15,
+ "val_loss": 0.839469,
+ "val_acc": 74.37
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.814889,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809867,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809185,
+ "gbest_acc": 76.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.805849,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.805849,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.804978,
+ "gbest_acc": 75.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.802106,
+ "gbest_acc": 75.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.800387,
+ "gbest_acc": 76.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.798266,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.798014,
+ "gbest_acc": 75.65,
+ "val_loss": 0.820349,
+ "val_acc": 74.76
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.795383,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.795281,
+ "gbest_acc": 75.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.792304,
+ "gbest_acc": 75.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.787911,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.787067,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78529,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78437,
+ "gbest_acc": 76.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.784272,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.782888,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.780001,
+ "gbest_acc": 76.1,
+ "val_loss": 0.807702,
+ "val_acc": 74.63
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.777134,
+ "gbest_acc": 76.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.776681,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.774309,
+ "gbest_acc": 76.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.77273,
+ "gbest_acc": 76.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.769951,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.769951,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.769731,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.767981,
+ "gbest_acc": 77.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.766536,
+ "gbest_acc": 76.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.764583,
+ "gbest_acc": 77.05,
+ "val_loss": 0.792164,
+ "val_acc": 75.53
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.762837,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.762082,
+ "gbest_acc": 77.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.759315,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.752516,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.751007,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74725,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.746098,
+ "gbest_acc": 76.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.745788,
+ "gbest_acc": 77.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.745191,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.744436,
+ "gbest_acc": 77.1,
+ "val_loss": 0.767359,
+ "val_acc": 76.36
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.741245,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.741245,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.740116,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.738993,
+ "gbest_acc": 78.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735917,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735182,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.734297,
+ "gbest_acc": 78.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.733332,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.730654,
+ "gbest_acc": 78.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.730654,
+ "gbest_acc": 78.4,
+ "val_loss": 0.752847,
+ "val_acc": 77.26
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.730654,
+ "gbest_acc": 78.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.728554,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.726947,
+ "gbest_acc": 78.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725314,
+ "gbest_acc": 78.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725314,
+ "gbest_acc": 78.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725314,
+ "gbest_acc": 78.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.724764,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.723705,
+ "gbest_acc": 78.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.722247,
+ "gbest_acc": 78.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.722247,
+ "gbest_acc": 78.3,
+ "val_loss": 0.744699,
+ "val_acc": 77.47
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721523,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.719858,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.717646,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.716682,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.71518,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.711599,
+ "gbest_acc": 78.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.7105,
+ "gbest_acc": 78.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.710267,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.707933,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.707688,
+ "gbest_acc": 78.35,
+ "val_loss": 0.732659,
+ "val_acc": 77.92
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705537,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705537,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.704138,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703339,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.70308,
+ "gbest_acc": 79.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.700847,
+ "gbest_acc": 78.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.697859,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.697157,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696877,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.694975,
+ "gbest_acc": 79.6,
+ "val_loss": 0.722579,
+ "val_acc": 78.48
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.694547,
+ "gbest_acc": 79.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.692499,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.692466,
+ "gbest_acc": 79.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.689819,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688078,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688078,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.687376,
+ "gbest_acc": 79.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.68465,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.683527,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.681125,
+ "gbest_acc": 79.1,
+ "val_loss": 0.709423,
+ "val_acc": 78.69
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.680759,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.679153,
+ "gbest_acc": 78.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.678429,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.676923,
+ "gbest_acc": 79.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.675477,
+ "gbest_acc": 79.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.672298,
+ "gbest_acc": 79.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.670975,
+ "gbest_acc": 80.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.670339,
+ "gbest_acc": 80.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.669837,
+ "gbest_acc": 79.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.669837,
+ "gbest_acc": 79.5,
+ "val_loss": 0.70384,
+ "val_acc": 78.55
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.668001,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.667334,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.666161,
+ "gbest_acc": 79.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.665956,
+ "gbest_acc": 79.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.664301,
+ "gbest_acc": 79.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.664202,
+ "gbest_acc": 79.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.662717,
+ "gbest_acc": 79.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.662012,
+ "gbest_acc": 80.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.662012,
+ "gbest_acc": 80.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.660902,
+ "gbest_acc": 80.2,
+ "val_loss": 0.69636,
+ "val_acc": 78.73
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.66035,
+ "gbest_acc": 80.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.659452,
+ "gbest_acc": 80.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.658635,
+ "gbest_acc": 80.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.658345,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.658088,
+ "gbest_acc": 80.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.657222,
+ "gbest_acc": 80.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.657222,
+ "gbest_acc": 80.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.656986,
+ "gbest_acc": 80.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.65585,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.655211,
+ "gbest_acc": 80.7,
+ "val_loss": 0.689905,
+ "val_acc": 79.3
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.655178,
+ "gbest_acc": 80.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.655088,
+ "gbest_acc": 80.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.654135,
+ "gbest_acc": 80.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.654135,
+ "gbest_acc": 80.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.654041,
+ "gbest_acc": 81.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.653674,
+ "gbest_acc": 80.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.652545,
+ "gbest_acc": 80.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.652545,
+ "gbest_acc": 80.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.651276,
+ "gbest_acc": 81.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.649193,
+ "gbest_acc": 81.1,
+ "val_loss": 0.684629,
+ "val_acc": 79.31
+ }
+ ],
+ "seed": 103,
+ "geometry_config": {
+ "config_id": "G0",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "exact V5 control"
+ }
+ }
+ ],
+ "G1": [
+ {
+ "config_id": "G1",
+ "gbest_loss": 0.794615,
+ "gbest_acc": 78.8,
+ "gbest_val_loss": 0.829049,
+ "gbest_val_acc": 76.77,
+ "val_selected_particle_idx": 23,
+ "val_selected_loss": 0.829049,
+ "val_selected_acc": 76.77,
+ "val_metrics": {
+ "accuracy": 76.77,
+ "nll": 0.829049,
+ "brier": 0.371229,
+ "ece": 0.179234,
+ "margin": 0.423688
+ },
+ "wall_time_sec": 30.903,
+ "optimization_wall_time_sec": 30.4903,
+ "validation_wall_time_sec": 0.4127,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420
+ ],
+ "pbest_update_counts": 12342,
+ "boundary_hits": 1302507,
+ "boundary_occupancy": 0.005681,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.163836,
+ "position_radius": 10.919968,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.310012,
+ "gbest_acc": 8.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.299881,
+ "gbest_acc": 9.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.285095,
+ "gbest_acc": 10.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.260516,
+ "gbest_acc": 11.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.234907,
+ "gbest_acc": 16.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.213634,
+ "gbest_acc": 20.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.191551,
+ "gbest_acc": 25.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.171802,
+ "gbest_acc": 26.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.160379,
+ "gbest_acc": 28.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.151926,
+ "gbest_acc": 28.45,
+ "val_loss": 2.156079,
+ "val_acc": 29.43
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.141272,
+ "gbest_acc": 29.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.12499,
+ "gbest_acc": 32.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.1087,
+ "gbest_acc": 31.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.096035,
+ "gbest_acc": 33.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.079533,
+ "gbest_acc": 32.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.063046,
+ "gbest_acc": 35.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.050247,
+ "gbest_acc": 34.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.037342,
+ "gbest_acc": 30.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.024687,
+ "gbest_acc": 31.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.004747,
+ "gbest_acc": 32.6,
+ "val_loss": 2.009202,
+ "val_acc": 32.94
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.998725,
+ "gbest_acc": 32.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.976254,
+ "gbest_acc": 37.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.961322,
+ "gbest_acc": 35.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.949461,
+ "gbest_acc": 35.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.948391,
+ "gbest_acc": 34.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.939639,
+ "gbest_acc": 37.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.928395,
+ "gbest_acc": 39.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.921444,
+ "gbest_acc": 39.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.919515,
+ "gbest_acc": 35.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.907651,
+ "gbest_acc": 38.3,
+ "val_loss": 1.921216,
+ "val_acc": 37.52
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.894041,
+ "gbest_acc": 35.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.873474,
+ "gbest_acc": 41.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.867333,
+ "gbest_acc": 37.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.860084,
+ "gbest_acc": 40.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.842857,
+ "gbest_acc": 40.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.834823,
+ "gbest_acc": 43.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.830443,
+ "gbest_acc": 40.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.829538,
+ "gbest_acc": 43.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.819344,
+ "gbest_acc": 42.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.819344,
+ "gbest_acc": 42.5,
+ "val_loss": 1.838749,
+ "val_acc": 41.57
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.80725,
+ "gbest_acc": 41.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.793426,
+ "gbest_acc": 44.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.788294,
+ "gbest_acc": 45.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.786772,
+ "gbest_acc": 48.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.784072,
+ "gbest_acc": 47.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.779962,
+ "gbest_acc": 47.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.761333,
+ "gbest_acc": 48.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.751215,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.742851,
+ "gbest_acc": 51.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.726624,
+ "gbest_acc": 52.5,
+ "val_loss": 1.739653,
+ "val_acc": 51.88
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.717962,
+ "gbest_acc": 50.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.697751,
+ "gbest_acc": 52.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.697751,
+ "gbest_acc": 52.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.69225,
+ "gbest_acc": 50.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.664045,
+ "gbest_acc": 53.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.664045,
+ "gbest_acc": 53.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.648705,
+ "gbest_acc": 55.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.64205,
+ "gbest_acc": 56.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.640077,
+ "gbest_acc": 55.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.628234,
+ "gbest_acc": 56.1,
+ "val_loss": 1.646208,
+ "val_acc": 54.31
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.628234,
+ "gbest_acc": 56.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.623011,
+ "gbest_acc": 57.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.620021,
+ "gbest_acc": 58.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597868,
+ "gbest_acc": 59.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5938,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585979,
+ "gbest_acc": 55.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.573343,
+ "gbest_acc": 54.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.573343,
+ "gbest_acc": 54.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.573343,
+ "gbest_acc": 54.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.568115,
+ "gbest_acc": 59.7,
+ "val_loss": 1.585753,
+ "val_acc": 58.36
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.565416,
+ "gbest_acc": 60.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.547302,
+ "gbest_acc": 58.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.547302,
+ "gbest_acc": 58.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.542205,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.534807,
+ "gbest_acc": 58.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.527881,
+ "gbest_acc": 59.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.527881,
+ "gbest_acc": 59.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.527881,
+ "gbest_acc": 59.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52569,
+ "gbest_acc": 58.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.515739,
+ "gbest_acc": 58.6,
+ "val_loss": 1.538976,
+ "val_acc": 56.93
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.512594,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.505421,
+ "gbest_acc": 59.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.503966,
+ "gbest_acc": 60.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.495691,
+ "gbest_acc": 62.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.480792,
+ "gbest_acc": 61.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.477899,
+ "gbest_acc": 60.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.477899,
+ "gbest_acc": 60.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.477899,
+ "gbest_acc": 60.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.469992,
+ "gbest_acc": 61.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.467467,
+ "gbest_acc": 62.45,
+ "val_loss": 1.48846,
+ "val_acc": 60.95
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.462598,
+ "gbest_acc": 60.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.455052,
+ "gbest_acc": 61.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.440767,
+ "gbest_acc": 62.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.440122,
+ "gbest_acc": 64.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.440122,
+ "gbest_acc": 64.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.43973,
+ "gbest_acc": 62.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.432979,
+ "gbest_acc": 63.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.423605,
+ "gbest_acc": 62.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.412776,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.405911,
+ "gbest_acc": 63.6,
+ "val_loss": 1.430713,
+ "val_acc": 62.33
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.405911,
+ "gbest_acc": 63.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.404251,
+ "gbest_acc": 65.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401759,
+ "gbest_acc": 64.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.394086,
+ "gbest_acc": 64.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.389878,
+ "gbest_acc": 64.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.389856,
+ "gbest_acc": 64.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388729,
+ "gbest_acc": 62.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.383464,
+ "gbest_acc": 63.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.383464,
+ "gbest_acc": 63.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.383464,
+ "gbest_acc": 63.6,
+ "val_loss": 1.405221,
+ "val_acc": 62.65
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.374071,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.372714,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.372714,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.372714,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.366754,
+ "gbest_acc": 63.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.366754,
+ "gbest_acc": 63.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357003,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.350764,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.345537,
+ "gbest_acc": 67.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.345537,
+ "gbest_acc": 67.25,
+ "val_loss": 1.369051,
+ "val_acc": 64.94
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.34242,
+ "gbest_acc": 67.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338541,
+ "gbest_acc": 67.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.336246,
+ "gbest_acc": 66.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.333104,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.330269,
+ "gbest_acc": 65.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.326915,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.326915,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.318862,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.307294,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.306937,
+ "gbest_acc": 68.2,
+ "val_loss": 1.33461,
+ "val_acc": 65.8
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.306937,
+ "gbest_acc": 68.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.306687,
+ "gbest_acc": 67.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.306687,
+ "gbest_acc": 67.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.302881,
+ "gbest_acc": 66.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.296001,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.296001,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.293887,
+ "gbest_acc": 68.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.286639,
+ "gbest_acc": 68.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.286028,
+ "gbest_acc": 67.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.284406,
+ "gbest_acc": 67.4,
+ "val_loss": 1.312134,
+ "val_acc": 65.11
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.284225,
+ "gbest_acc": 67.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282289,
+ "gbest_acc": 68.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.281705,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.281705,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.28057,
+ "gbest_acc": 68.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.270269,
+ "gbest_acc": 68.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.264456,
+ "gbest_acc": 68.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.264103,
+ "gbest_acc": 68.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.264103,
+ "gbest_acc": 68.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.264103,
+ "gbest_acc": 68.95,
+ "val_loss": 1.293838,
+ "val_acc": 67.68
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.262442,
+ "gbest_acc": 68.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.256164,
+ "gbest_acc": 69.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.252586,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.252586,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.248474,
+ "gbest_acc": 69.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.244713,
+ "gbest_acc": 69.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.244713,
+ "gbest_acc": 69.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.244713,
+ "gbest_acc": 69.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.239786,
+ "gbest_acc": 70.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.237382,
+ "gbest_acc": 70.2,
+ "val_loss": 1.262164,
+ "val_acc": 68.04
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.237382,
+ "gbest_acc": 70.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.234788,
+ "gbest_acc": 69.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.231423,
+ "gbest_acc": 69.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.22466,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.22466,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.218691,
+ "gbest_acc": 69.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.216692,
+ "gbest_acc": 69.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.216641,
+ "gbest_acc": 70.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.216641,
+ "gbest_acc": 70.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.2088,
+ "gbest_acc": 70.45,
+ "val_loss": 1.238752,
+ "val_acc": 67.6
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.204274,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.197729,
+ "gbest_acc": 70.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.193468,
+ "gbest_acc": 70.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.191144,
+ "gbest_acc": 69.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.191144,
+ "gbest_acc": 69.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.184082,
+ "gbest_acc": 70.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.182378,
+ "gbest_acc": 70.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.178355,
+ "gbest_acc": 70.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.178355,
+ "gbest_acc": 70.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177966,
+ "gbest_acc": 70.6,
+ "val_loss": 1.208975,
+ "val_acc": 67.7
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.175245,
+ "gbest_acc": 71.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.170557,
+ "gbest_acc": 70.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.163833,
+ "gbest_acc": 70.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.163833,
+ "gbest_acc": 70.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.162038,
+ "gbest_acc": 70.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.15472,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.152441,
+ "gbest_acc": 71.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.152441,
+ "gbest_acc": 71.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.152441,
+ "gbest_acc": 71.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.149805,
+ "gbest_acc": 70.6,
+ "val_loss": 1.183182,
+ "val_acc": 68.76
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.149805,
+ "gbest_acc": 70.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146789,
+ "gbest_acc": 71.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146789,
+ "gbest_acc": 71.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.142664,
+ "gbest_acc": 73.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.140243,
+ "gbest_acc": 71.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.140243,
+ "gbest_acc": 71.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.138495,
+ "gbest_acc": 71.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136353,
+ "gbest_acc": 72.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.135092,
+ "gbest_acc": 71.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.135092,
+ "gbest_acc": 71.75,
+ "val_loss": 1.16729,
+ "val_acc": 68.9
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132646,
+ "gbest_acc": 71.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.129252,
+ "gbest_acc": 71.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.1258,
+ "gbest_acc": 71.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.121853,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.121853,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12095,
+ "gbest_acc": 72.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.119158,
+ "gbest_acc": 72.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.117539,
+ "gbest_acc": 72.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.114767,
+ "gbest_acc": 72.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.11307,
+ "gbest_acc": 72.7,
+ "val_loss": 1.140975,
+ "val_acc": 70.48
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.1104,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.105516,
+ "gbest_acc": 73.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.103499,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.103499,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.100192,
+ "gbest_acc": 73.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.099035,
+ "gbest_acc": 72.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.095861,
+ "gbest_acc": 73.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.095861,
+ "gbest_acc": 73.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.092363,
+ "gbest_acc": 73.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.090247,
+ "gbest_acc": 73.35,
+ "val_loss": 1.117736,
+ "val_acc": 71.29
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.087638,
+ "gbest_acc": 73.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.085616,
+ "gbest_acc": 73.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.082443,
+ "gbest_acc": 73.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.08155,
+ "gbest_acc": 72.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.08155,
+ "gbest_acc": 72.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.079649,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.076205,
+ "gbest_acc": 73.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.075097,
+ "gbest_acc": 73.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.072488,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.072488,
+ "gbest_acc": 74.2,
+ "val_loss": 1.101127,
+ "val_acc": 70.75
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.072488,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.071087,
+ "gbest_acc": 74.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.069604,
+ "gbest_acc": 73.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.0677,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.0677,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.0677,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.066931,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057868,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057868,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057868,
+ "gbest_acc": 73.95,
+ "val_loss": 1.08788,
+ "val_acc": 71.29
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057868,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.05546,
+ "gbest_acc": 73.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.052271,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.05083,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.048794,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.047063,
+ "gbest_acc": 73.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.045236,
+ "gbest_acc": 73.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.044525,
+ "gbest_acc": 73.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.042034,
+ "gbest_acc": 73.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.039485,
+ "gbest_acc": 73.45,
+ "val_loss": 1.072365,
+ "val_acc": 70.7
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.037716,
+ "gbest_acc": 73.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.036318,
+ "gbest_acc": 74.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.034629,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.034629,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.034629,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.033459,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.029166,
+ "gbest_acc": 73.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.028876,
+ "gbest_acc": 74.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023856,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023856,
+ "gbest_acc": 74.65,
+ "val_loss": 1.05347,
+ "val_acc": 72.02
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.022283,
+ "gbest_acc": 74.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.021825,
+ "gbest_acc": 73.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.019406,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.019406,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.018163,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.015714,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.0122,
+ "gbest_acc": 74.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.01154,
+ "gbest_acc": 74.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.008649,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.008601,
+ "gbest_acc": 74.3,
+ "val_loss": 1.03574,
+ "val_acc": 71.89
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.003861,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.003861,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996466,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996466,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.994301,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.992628,
+ "gbest_acc": 74.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.992628,
+ "gbest_acc": 74.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.992628,
+ "gbest_acc": 74.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.991457,
+ "gbest_acc": 74.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.989228,
+ "gbest_acc": 74.1,
+ "val_loss": 1.017473,
+ "val_acc": 72.23
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.988468,
+ "gbest_acc": 74.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.987877,
+ "gbest_acc": 74.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.986252,
+ "gbest_acc": 74.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.98472,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.982308,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.98202,
+ "gbest_acc": 74.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.979482,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.979482,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.979105,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.977673,
+ "gbest_acc": 74.2,
+ "val_loss": 1.00481,
+ "val_acc": 71.9
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.976693,
+ "gbest_acc": 74.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974487,
+ "gbest_acc": 74.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.973291,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972766,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972766,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972417,
+ "gbest_acc": 74.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.970265,
+ "gbest_acc": 74.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.969626,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.966226,
+ "gbest_acc": 74.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.965751,
+ "gbest_acc": 74.75,
+ "val_loss": 0.992057,
+ "val_acc": 73.04
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.96384,
+ "gbest_acc": 74.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.960886,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.959888,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.958589,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.954265,
+ "gbest_acc": 74.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.953607,
+ "gbest_acc": 74.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.953501,
+ "gbest_acc": 74.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.953223,
+ "gbest_acc": 74.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.950902,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.947104,
+ "gbest_acc": 74.65,
+ "val_loss": 0.975703,
+ "val_acc": 73.23
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.945159,
+ "gbest_acc": 74.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.944835,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.940521,
+ "gbest_acc": 74.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.94008,
+ "gbest_acc": 74.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.93594,
+ "gbest_acc": 75.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.932494,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.931175,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.931175,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.928582,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.927048,
+ "gbest_acc": 75.45,
+ "val_loss": 0.956894,
+ "val_acc": 73.42
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.926488,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.923755,
+ "gbest_acc": 75.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.918929,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.918545,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.918545,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.918545,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.916016,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.914054,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.911837,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.910606,
+ "gbest_acc": 76.1,
+ "val_loss": 0.942871,
+ "val_acc": 73.88
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.906125,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.90537,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.903694,
+ "gbest_acc": 75.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.901159,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.898595,
+ "gbest_acc": 76.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.898595,
+ "gbest_acc": 76.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.895876,
+ "gbest_acc": 76.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.891747,
+ "gbest_acc": 76.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.891408,
+ "gbest_acc": 77.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.889417,
+ "gbest_acc": 76.85,
+ "val_loss": 0.925336,
+ "val_acc": 74.28
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.889039,
+ "gbest_acc": 76.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.886435,
+ "gbest_acc": 76.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884131,
+ "gbest_acc": 76.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884131,
+ "gbest_acc": 76.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882945,
+ "gbest_acc": 76.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.879842,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.879374,
+ "gbest_acc": 77.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875549,
+ "gbest_acc": 76.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875549,
+ "gbest_acc": 76.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.872364,
+ "gbest_acc": 76.8,
+ "val_loss": 0.909555,
+ "val_acc": 74.4
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.872364,
+ "gbest_acc": 76.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871942,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871074,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.870295,
+ "gbest_acc": 77.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.866029,
+ "gbest_acc": 77.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.866029,
+ "gbest_acc": 77.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.864163,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.862767,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.862767,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.862767,
+ "gbest_acc": 77.5,
+ "val_loss": 0.90049,
+ "val_acc": 74.69
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.860316,
+ "gbest_acc": 77.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.859693,
+ "gbest_acc": 76.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.856338,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.856338,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.856338,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.855933,
+ "gbest_acc": 76.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.854668,
+ "gbest_acc": 76.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.853454,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.853286,
+ "gbest_acc": 77.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.851038,
+ "gbest_acc": 77.35,
+ "val_loss": 0.888211,
+ "val_acc": 75.1
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849086,
+ "gbest_acc": 77.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849086,
+ "gbest_acc": 77.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849086,
+ "gbest_acc": 77.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849086,
+ "gbest_acc": 77.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.846924,
+ "gbest_acc": 77.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.845396,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.844744,
+ "gbest_acc": 77.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.842231,
+ "gbest_acc": 77.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.841167,
+ "gbest_acc": 77.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.841167,
+ "gbest_acc": 77.75,
+ "val_loss": 0.8787,
+ "val_acc": 74.96
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.839602,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.839512,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.837016,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.836639,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.835334,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.835161,
+ "gbest_acc": 77.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.830294,
+ "gbest_acc": 77.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.829073,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.828256,
+ "gbest_acc": 78.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.828256,
+ "gbest_acc": 78.2,
+ "val_loss": 0.864934,
+ "val_acc": 75.5
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.828256,
+ "gbest_acc": 78.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.82711,
+ "gbest_acc": 77.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.823439,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.823439,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.823208,
+ "gbest_acc": 78.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821909,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821909,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821909,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821288,
+ "gbest_acc": 78.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.819911,
+ "gbest_acc": 78.35,
+ "val_loss": 0.853038,
+ "val_acc": 76.14
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.819445,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.818612,
+ "gbest_acc": 78.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.817562,
+ "gbest_acc": 78.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.817562,
+ "gbest_acc": 78.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.815567,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.812757,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.812757,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.81176,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.81176,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809788,
+ "gbest_acc": 78.5,
+ "val_loss": 0.843894,
+ "val_acc": 76.34
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.808535,
+ "gbest_acc": 78.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.804753,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.804594,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.801163,
+ "gbest_acc": 79.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.799657,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.799657,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.798326,
+ "gbest_acc": 79.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.79679,
+ "gbest_acc": 79.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.79679,
+ "gbest_acc": 79.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.794615,
+ "gbest_acc": 78.8,
+ "val_loss": 0.829049,
+ "val_acc": 76.77
+ }
+ ],
+ "seed": 101,
+ "geometry_config": {
+ "config_id": "G1",
+ "scale_type": "global_rms",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate anisotropic per-tensor scaling"
+ }
+ },
+ {
+ "config_id": "G1",
+ "gbest_loss": 0.942968,
+ "gbest_acc": 75.25,
+ "gbest_val_loss": 0.959953,
+ "gbest_val_acc": 74.41,
+ "val_selected_particle_idx": 41,
+ "val_selected_loss": 0.959714,
+ "val_selected_acc": 74.56,
+ "val_metrics": {
+ "accuracy": 74.56,
+ "nll": 0.959714,
+ "brier": 0.432698,
+ "ece": 0.236244,
+ "margin": 0.339033
+ },
+ "wall_time_sec": 31.7701,
+ "optimization_wall_time_sec": 31.3513,
+ "validation_wall_time_sec": 0.4188,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420
+ ],
+ "pbest_update_counts": 13364,
+ "boundary_hits": 962677,
+ "boundary_occupancy": 0.004199,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.108827,
+ "position_radius": 7.494582,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.308251,
+ "gbest_acc": 6.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.300112,
+ "gbest_acc": 7.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.28583,
+ "gbest_acc": 10.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.27106,
+ "gbest_acc": 12.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.253277,
+ "gbest_acc": 11.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.237694,
+ "gbest_acc": 16.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.222606,
+ "gbest_acc": 14.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.20703,
+ "gbest_acc": 16.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.191514,
+ "gbest_acc": 14.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.167835,
+ "gbest_acc": 21.0,
+ "val_loss": 2.161986,
+ "val_acc": 21.47
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.157919,
+ "gbest_acc": 23.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.140123,
+ "gbest_acc": 23.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.126402,
+ "gbest_acc": 24.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.112596,
+ "gbest_acc": 26.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.10033,
+ "gbest_acc": 26.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.081214,
+ "gbest_acc": 29.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.072942,
+ "gbest_acc": 29.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.05064,
+ "gbest_acc": 31.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.03623,
+ "gbest_acc": 31.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.021289,
+ "gbest_acc": 33.5,
+ "val_loss": 2.017474,
+ "val_acc": 32.88
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.993636,
+ "gbest_acc": 34.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.978348,
+ "gbest_acc": 35.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.964849,
+ "gbest_acc": 37.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.949536,
+ "gbest_acc": 35.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.94365,
+ "gbest_acc": 36.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.94365,
+ "gbest_acc": 36.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.941805,
+ "gbest_acc": 35.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.928597,
+ "gbest_acc": 37.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.893885,
+ "gbest_acc": 38.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.890626,
+ "gbest_acc": 40.35,
+ "val_loss": 1.886238,
+ "val_acc": 41.16
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.870036,
+ "gbest_acc": 40.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.850066,
+ "gbest_acc": 40.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.841049,
+ "gbest_acc": 41.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.835984,
+ "gbest_acc": 42.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.826841,
+ "gbest_acc": 41.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.820109,
+ "gbest_acc": 43.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.811803,
+ "gbest_acc": 43.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.808548,
+ "gbest_acc": 42.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.808548,
+ "gbest_acc": 42.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.808548,
+ "gbest_acc": 42.75,
+ "val_loss": 1.809921,
+ "val_acc": 44.16
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.80496,
+ "gbest_acc": 43.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.791795,
+ "gbest_acc": 46.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.791795,
+ "gbest_acc": 46.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.791795,
+ "gbest_acc": 46.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.784787,
+ "gbest_acc": 45.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.775544,
+ "gbest_acc": 45.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.768946,
+ "gbest_acc": 46.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.757248,
+ "gbest_acc": 44.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.757248,
+ "gbest_acc": 44.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.751049,
+ "gbest_acc": 45.5,
+ "val_loss": 1.752816,
+ "val_acc": 46.4
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.740379,
+ "gbest_acc": 46.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.731848,
+ "gbest_acc": 48.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.722702,
+ "gbest_acc": 47.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.718968,
+ "gbest_acc": 50.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711896,
+ "gbest_acc": 51.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.700388,
+ "gbest_acc": 50.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.700388,
+ "gbest_acc": 50.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.700388,
+ "gbest_acc": 50.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.699439,
+ "gbest_acc": 51.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.693362,
+ "gbest_acc": 51.25,
+ "val_loss": 1.692775,
+ "val_acc": 52.19
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.682225,
+ "gbest_acc": 50.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.673416,
+ "gbest_acc": 50.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.667821,
+ "gbest_acc": 50.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.664708,
+ "gbest_acc": 50.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.662051,
+ "gbest_acc": 51.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.658936,
+ "gbest_acc": 51.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.641213,
+ "gbest_acc": 52.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.637479,
+ "gbest_acc": 53.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.630264,
+ "gbest_acc": 52.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.630264,
+ "gbest_acc": 52.35,
+ "val_loss": 1.630862,
+ "val_acc": 51.77
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.630264,
+ "gbest_acc": 52.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.630264,
+ "gbest_acc": 52.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629805,
+ "gbest_acc": 52.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.627116,
+ "gbest_acc": 52.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.6188,
+ "gbest_acc": 54.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.617375,
+ "gbest_acc": 53.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.614618,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.607948,
+ "gbest_acc": 55.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.605273,
+ "gbest_acc": 55.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597137,
+ "gbest_acc": 56.75,
+ "val_loss": 1.599704,
+ "val_acc": 56.43
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597137,
+ "gbest_acc": 56.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597137,
+ "gbest_acc": 56.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597137,
+ "gbest_acc": 56.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.594432,
+ "gbest_acc": 56.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.590899,
+ "gbest_acc": 55.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.590899,
+ "gbest_acc": 55.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.583148,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.58168,
+ "gbest_acc": 56.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.58168,
+ "gbest_acc": 56.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.579615,
+ "gbest_acc": 56.05,
+ "val_loss": 1.581267,
+ "val_acc": 55.65
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.577744,
+ "gbest_acc": 56.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.575662,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.563363,
+ "gbest_acc": 56.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.55747,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.555303,
+ "gbest_acc": 58.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.552513,
+ "gbest_acc": 58.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.550836,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.544681,
+ "gbest_acc": 58.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.544681,
+ "gbest_acc": 58.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.544681,
+ "gbest_acc": 58.85,
+ "val_loss": 1.545637,
+ "val_acc": 57.79
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.538543,
+ "gbest_acc": 58.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.533564,
+ "gbest_acc": 58.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.53096,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.529279,
+ "gbest_acc": 58.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.527115,
+ "gbest_acc": 56.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52523,
+ "gbest_acc": 56.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.516989,
+ "gbest_acc": 57.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.510704,
+ "gbest_acc": 56.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.510704,
+ "gbest_acc": 56.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.510704,
+ "gbest_acc": 56.95,
+ "val_loss": 1.514346,
+ "val_acc": 58.19
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.510704,
+ "gbest_acc": 56.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.506901,
+ "gbest_acc": 57.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497929,
+ "gbest_acc": 58.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.489772,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.481681,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.478712,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.477022,
+ "gbest_acc": 59.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.471952,
+ "gbest_acc": 59.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.467525,
+ "gbest_acc": 59.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.464259,
+ "gbest_acc": 61.5,
+ "val_loss": 1.469462,
+ "val_acc": 60.66
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.462724,
+ "gbest_acc": 62.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.461775,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.4613,
+ "gbest_acc": 61.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.4613,
+ "gbest_acc": 61.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.456926,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.456787,
+ "gbest_acc": 59.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452214,
+ "gbest_acc": 62.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.448971,
+ "gbest_acc": 61.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.444302,
+ "gbest_acc": 63.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.43553,
+ "gbest_acc": 60.85,
+ "val_loss": 1.438712,
+ "val_acc": 61.24
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.431994,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.428049,
+ "gbest_acc": 61.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.426504,
+ "gbest_acc": 63.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.425456,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.41925,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.414926,
+ "gbest_acc": 61.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.411188,
+ "gbest_acc": 64.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.41066,
+ "gbest_acc": 62.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.407778,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.406756,
+ "gbest_acc": 62.85,
+ "val_loss": 1.410775,
+ "val_acc": 62.73
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.406756,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.402033,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.396883,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.396883,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.396875,
+ "gbest_acc": 63.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.390885,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.390885,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.390885,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.390885,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388658,
+ "gbest_acc": 63.5,
+ "val_loss": 1.392259,
+ "val_acc": 63.24
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.38851,
+ "gbest_acc": 62.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.385692,
+ "gbest_acc": 64.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.38492,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.381533,
+ "gbest_acc": 64.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.372466,
+ "gbest_acc": 63.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.372466,
+ "gbest_acc": 63.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.370312,
+ "gbest_acc": 63.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.368083,
+ "gbest_acc": 64.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.365853,
+ "gbest_acc": 65.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.363151,
+ "gbest_acc": 64.45,
+ "val_loss": 1.371205,
+ "val_acc": 64.58
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.354694,
+ "gbest_acc": 65.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.35427,
+ "gbest_acc": 63.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.35427,
+ "gbest_acc": 63.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.35427,
+ "gbest_acc": 63.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.350407,
+ "gbest_acc": 63.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.346872,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.342702,
+ "gbest_acc": 64.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.339579,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.335717,
+ "gbest_acc": 63.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.333511,
+ "gbest_acc": 64.95,
+ "val_loss": 1.341098,
+ "val_acc": 65.23
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.333511,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331779,
+ "gbest_acc": 64.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.32793,
+ "gbest_acc": 64.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.323951,
+ "gbest_acc": 66.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.323951,
+ "gbest_acc": 66.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.323951,
+ "gbest_acc": 66.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.323951,
+ "gbest_acc": 66.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.323943,
+ "gbest_acc": 66.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.322509,
+ "gbest_acc": 65.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.317337,
+ "gbest_acc": 66.15,
+ "val_loss": 1.323069,
+ "val_acc": 66.32
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.317337,
+ "gbest_acc": 66.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.314115,
+ "gbest_acc": 66.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.312029,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.307908,
+ "gbest_acc": 66.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.30162,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.30162,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.301001,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.297203,
+ "gbest_acc": 66.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.29467,
+ "gbest_acc": 67.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.293032,
+ "gbest_acc": 67.65,
+ "val_loss": 1.299349,
+ "val_acc": 67.24
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.293032,
+ "gbest_acc": 67.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.290876,
+ "gbest_acc": 66.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.288553,
+ "gbest_acc": 66.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.284604,
+ "gbest_acc": 66.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.281219,
+ "gbest_acc": 66.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.281219,
+ "gbest_acc": 66.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.278767,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.275515,
+ "gbest_acc": 66.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.275515,
+ "gbest_acc": 66.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.275246,
+ "gbest_acc": 66.95,
+ "val_loss": 1.282521,
+ "val_acc": 67.01
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.275246,
+ "gbest_acc": 66.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.275246,
+ "gbest_acc": 66.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.271419,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.267608,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.266697,
+ "gbest_acc": 67.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.261219,
+ "gbest_acc": 66.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.25923,
+ "gbest_acc": 67.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.254076,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.250961,
+ "gbest_acc": 65.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.242633,
+ "gbest_acc": 67.9,
+ "val_loss": 1.250727,
+ "val_acc": 67.45
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.238168,
+ "gbest_acc": 66.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.235902,
+ "gbest_acc": 67.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.235902,
+ "gbest_acc": 67.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.233577,
+ "gbest_acc": 67.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.228488,
+ "gbest_acc": 67.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.222879,
+ "gbest_acc": 68.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.222503,
+ "gbest_acc": 67.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.214512,
+ "gbest_acc": 67.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.210555,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199453,
+ "gbest_acc": 68.15,
+ "val_loss": 1.207994,
+ "val_acc": 68.51
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199453,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.198662,
+ "gbest_acc": 67.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.197566,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.197566,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.195657,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.1917,
+ "gbest_acc": 68.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.184783,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.184783,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.184142,
+ "gbest_acc": 68.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.184142,
+ "gbest_acc": 68.85,
+ "val_loss": 1.191995,
+ "val_acc": 68.95
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.183894,
+ "gbest_acc": 68.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.183068,
+ "gbest_acc": 68.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.181697,
+ "gbest_acc": 68.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.17958,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177353,
+ "gbest_acc": 68.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.174732,
+ "gbest_acc": 68.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.170771,
+ "gbest_acc": 69.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.170771,
+ "gbest_acc": 69.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.168824,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.1683,
+ "gbest_acc": 68.5,
+ "val_loss": 1.177935,
+ "val_acc": 69.12
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.165933,
+ "gbest_acc": 68.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.163221,
+ "gbest_acc": 69.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.157994,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.153044,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.148855,
+ "gbest_acc": 69.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.148855,
+ "gbest_acc": 69.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.148855,
+ "gbest_acc": 69.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146592,
+ "gbest_acc": 70.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.145531,
+ "gbest_acc": 69.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.144501,
+ "gbest_acc": 70.0,
+ "val_loss": 1.154622,
+ "val_acc": 70.21
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.144501,
+ "gbest_acc": 70.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.144501,
+ "gbest_acc": 70.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.143444,
+ "gbest_acc": 69.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.141171,
+ "gbest_acc": 70.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.13943,
+ "gbest_acc": 70.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.138148,
+ "gbest_acc": 70.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.135749,
+ "gbest_acc": 71.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132314,
+ "gbest_acc": 71.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132314,
+ "gbest_acc": 71.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132314,
+ "gbest_acc": 71.6,
+ "val_loss": 1.142806,
+ "val_acc": 71.13
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.127449,
+ "gbest_acc": 70.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.127449,
+ "gbest_acc": 70.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.126741,
+ "gbest_acc": 70.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.123549,
+ "gbest_acc": 70.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.122581,
+ "gbest_acc": 70.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.119281,
+ "gbest_acc": 72.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.117534,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.114806,
+ "gbest_acc": 71.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.114806,
+ "gbest_acc": 71.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.112311,
+ "gbest_acc": 72.35,
+ "val_loss": 1.120329,
+ "val_acc": 71.57
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.111739,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.109535,
+ "gbest_acc": 72.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.109535,
+ "gbest_acc": 72.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.109535,
+ "gbest_acc": 72.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.108432,
+ "gbest_acc": 72.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106026,
+ "gbest_acc": 73.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.102711,
+ "gbest_acc": 73.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.102711,
+ "gbest_acc": 73.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.100747,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.097947,
+ "gbest_acc": 72.4,
+ "val_loss": 1.104596,
+ "val_acc": 71.82
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.095486,
+ "gbest_acc": 71.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.093053,
+ "gbest_acc": 71.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.090653,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.08376,
+ "gbest_acc": 72.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.08376,
+ "gbest_acc": 72.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.08376,
+ "gbest_acc": 72.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.08376,
+ "gbest_acc": 72.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.082681,
+ "gbest_acc": 72.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.08136,
+ "gbest_acc": 72.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.081316,
+ "gbest_acc": 72.8,
+ "val_loss": 1.092051,
+ "val_acc": 72.27
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.078696,
+ "gbest_acc": 73.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.077438,
+ "gbest_acc": 73.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.073121,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.068913,
+ "gbest_acc": 73.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.068641,
+ "gbest_acc": 73.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.068556,
+ "gbest_acc": 73.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.066722,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.063709,
+ "gbest_acc": 73.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.061703,
+ "gbest_acc": 73.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.058363,
+ "gbest_acc": 73.0,
+ "val_loss": 1.070422,
+ "val_acc": 72.3
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057168,
+ "gbest_acc": 73.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.055279,
+ "gbest_acc": 73.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.05481,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.053615,
+ "gbest_acc": 73.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.052216,
+ "gbest_acc": 73.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.052216,
+ "gbest_acc": 73.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.052216,
+ "gbest_acc": 73.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.05072,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.049052,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.045241,
+ "gbest_acc": 74.2,
+ "val_loss": 1.056893,
+ "val_acc": 72.9
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.044178,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.043346,
+ "gbest_acc": 73.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.042452,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.04066,
+ "gbest_acc": 74.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.04066,
+ "gbest_acc": 74.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.039771,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.039493,
+ "gbest_acc": 74.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.037351,
+ "gbest_acc": 74.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.036417,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.035451,
+ "gbest_acc": 74.0,
+ "val_loss": 1.048482,
+ "val_acc": 72.7
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.034907,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.032869,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.031192,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.028577,
+ "gbest_acc": 74.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.027766,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.026359,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.02425,
+ "gbest_acc": 74.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.024082,
+ "gbest_acc": 74.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.021234,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.021234,
+ "gbest_acc": 74.55,
+ "val_loss": 1.034217,
+ "val_acc": 73.54
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.021234,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.021234,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.01862,
+ "gbest_acc": 74.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.017493,
+ "gbest_acc": 74.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.016493,
+ "gbest_acc": 74.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.0163,
+ "gbest_acc": 74.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.016052,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.013792,
+ "gbest_acc": 74.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.011423,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.011423,
+ "gbest_acc": 74.65,
+ "val_loss": 1.026605,
+ "val_acc": 73.16
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.008582,
+ "gbest_acc": 74.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.007987,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.007421,
+ "gbest_acc": 74.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.004956,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.004956,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.004725,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.002827,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.002826,
+ "gbest_acc": 75.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.002738,
+ "gbest_acc": 75.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.002723,
+ "gbest_acc": 75.45,
+ "val_loss": 1.018488,
+ "val_acc": 73.5
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.002254,
+ "gbest_acc": 74.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.000941,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.000941,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.000583,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.998712,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.998712,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.998045,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996658,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996658,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996658,
+ "gbest_acc": 75.05,
+ "val_loss": 1.013715,
+ "val_acc": 73.54
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996658,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.996531,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.99444,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.991907,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990471,
+ "gbest_acc": 75.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.988618,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.985173,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.985173,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.985173,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.984358,
+ "gbest_acc": 75.55,
+ "val_loss": 1.001588,
+ "val_acc": 73.8
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.982391,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.980727,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.977035,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.976536,
+ "gbest_acc": 75.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974504,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974504,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974504,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.973644,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.973644,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.971407,
+ "gbest_acc": 75.15,
+ "val_loss": 0.990217,
+ "val_acc": 73.57
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.971021,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.969968,
+ "gbest_acc": 75.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.969042,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967734,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967734,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967734,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967571,
+ "gbest_acc": 75.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.96715,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.96715,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.966756,
+ "gbest_acc": 75.75,
+ "val_loss": 0.983319,
+ "val_acc": 74.01
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.965799,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.964738,
+ "gbest_acc": 76.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.964386,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.963145,
+ "gbest_acc": 76.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.962854,
+ "gbest_acc": 74.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.962197,
+ "gbest_acc": 76.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.962044,
+ "gbest_acc": 75.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.959452,
+ "gbest_acc": 76.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.958129,
+ "gbest_acc": 76.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.956304,
+ "gbest_acc": 75.75,
+ "val_loss": 0.973083,
+ "val_acc": 74.27
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.955952,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.955278,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.954907,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.954282,
+ "gbest_acc": 75.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.954282,
+ "gbest_acc": 75.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.953915,
+ "gbest_acc": 75.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.952407,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.951101,
+ "gbest_acc": 76.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.951101,
+ "gbest_acc": 76.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.950827,
+ "gbest_acc": 76.3,
+ "val_loss": 0.96712,
+ "val_acc": 74.64
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.94934,
+ "gbest_acc": 75.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.949052,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.946526,
+ "gbest_acc": 76.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.946526,
+ "gbest_acc": 76.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.946098,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.944823,
+ "gbest_acc": 75.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.943351,
+ "gbest_acc": 75.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.943035,
+ "gbest_acc": 75.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.942968,
+ "gbest_acc": 75.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.942968,
+ "gbest_acc": 75.25,
+ "val_loss": 0.959953,
+ "val_acc": 74.41
+ }
+ ],
+ "seed": 102,
+ "geometry_config": {
+ "config_id": "G1",
+ "scale_type": "global_rms",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate anisotropic per-tensor scaling"
+ }
+ },
+ {
+ "config_id": "G1",
+ "gbest_loss": 0.689941,
+ "gbest_acc": 80.05,
+ "gbest_val_loss": 0.712515,
+ "gbest_val_acc": 79.53,
+ "val_selected_particle_idx": 23,
+ "val_selected_loss": 0.712515,
+ "val_selected_acc": 79.53,
+ "val_metrics": {
+ "accuracy": 79.53,
+ "nll": 0.712515,
+ "brier": 0.3262,
+ "ece": 0.153736,
+ "margin": 0.485345
+ },
+ "wall_time_sec": 39.6442,
+ "optimization_wall_time_sec": 39.1967,
+ "validation_wall_time_sec": 0.4475,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420,
+ 420
+ ],
+ "pbest_update_counts": 13549,
+ "boundary_hits": 1067771,
+ "boundary_occupancy": 0.004657,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.091638,
+ "position_radius": 6.172244,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.309893,
+ "gbest_acc": 10.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.30143,
+ "gbest_acc": 10.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.285158,
+ "gbest_acc": 9.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.26472,
+ "gbest_acc": 11.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.242381,
+ "gbest_acc": 16.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.209798,
+ "gbest_acc": 17.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.179847,
+ "gbest_acc": 20.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.143448,
+ "gbest_acc": 23.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.122672,
+ "gbest_acc": 25.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.101889,
+ "gbest_acc": 27.1,
+ "val_loss": 2.104325,
+ "val_acc": 27.35
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.089032,
+ "gbest_acc": 29.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.076806,
+ "gbest_acc": 30.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.047444,
+ "gbest_acc": 31.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.018426,
+ "gbest_acc": 33.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.003399,
+ "gbest_acc": 35.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.991664,
+ "gbest_acc": 33.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.977967,
+ "gbest_acc": 38.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.949925,
+ "gbest_acc": 38.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.929959,
+ "gbest_acc": 40.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.908147,
+ "gbest_acc": 39.1,
+ "val_loss": 1.914648,
+ "val_acc": 39.9
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.894993,
+ "gbest_acc": 41.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.880967,
+ "gbest_acc": 41.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.869496,
+ "gbest_acc": 41.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.818546,
+ "gbest_acc": 42.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.80648,
+ "gbest_acc": 44.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.792469,
+ "gbest_acc": 42.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.766288,
+ "gbest_acc": 43.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.765175,
+ "gbest_acc": 45.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74851,
+ "gbest_acc": 44.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.727359,
+ "gbest_acc": 49.1,
+ "val_loss": 1.735428,
+ "val_acc": 49.95
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711171,
+ "gbest_acc": 48.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.688532,
+ "gbest_acc": 50.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687437,
+ "gbest_acc": 51.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687437,
+ "gbest_acc": 51.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.674679,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.657281,
+ "gbest_acc": 52.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.657234,
+ "gbest_acc": 53.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.648957,
+ "gbest_acc": 53.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.648422,
+ "gbest_acc": 52.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.641706,
+ "gbest_acc": 53.7,
+ "val_loss": 1.643881,
+ "val_acc": 55.11
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.632738,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629456,
+ "gbest_acc": 55.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.622095,
+ "gbest_acc": 53.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.605503,
+ "gbest_acc": 55.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.603037,
+ "gbest_acc": 55.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597725,
+ "gbest_acc": 54.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.593385,
+ "gbest_acc": 55.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.58756,
+ "gbest_acc": 56.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.579526,
+ "gbest_acc": 57.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.579526,
+ "gbest_acc": 57.0,
+ "val_loss": 1.588577,
+ "val_acc": 57.37
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5654,
+ "gbest_acc": 56.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5654,
+ "gbest_acc": 56.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5654,
+ "gbest_acc": 56.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5654,
+ "gbest_acc": 56.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.560202,
+ "gbest_acc": 58.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.555944,
+ "gbest_acc": 58.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.547064,
+ "gbest_acc": 57.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.536907,
+ "gbest_acc": 58.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.523391,
+ "gbest_acc": 57.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.502182,
+ "gbest_acc": 59.35,
+ "val_loss": 1.506936,
+ "val_acc": 59.62
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.502182,
+ "gbest_acc": 59.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.49422,
+ "gbest_acc": 58.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.491681,
+ "gbest_acc": 59.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.483712,
+ "gbest_acc": 57.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.476296,
+ "gbest_acc": 58.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.46828,
+ "gbest_acc": 58.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.46745,
+ "gbest_acc": 59.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460452,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.448492,
+ "gbest_acc": 61.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.438388,
+ "gbest_acc": 60.55,
+ "val_loss": 1.451499,
+ "val_acc": 59.65
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.438388,
+ "gbest_acc": 60.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.433967,
+ "gbest_acc": 60.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.424599,
+ "gbest_acc": 60.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.424599,
+ "gbest_acc": 60.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.409288,
+ "gbest_acc": 60.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.39938,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.39938,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.395015,
+ "gbest_acc": 61.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.389278,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388726,
+ "gbest_acc": 60.1,
+ "val_loss": 1.399049,
+ "val_acc": 60.94
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.378491,
+ "gbest_acc": 61.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.372455,
+ "gbest_acc": 61.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.36346,
+ "gbest_acc": 61.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.354573,
+ "gbest_acc": 62.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348208,
+ "gbest_acc": 64.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348208,
+ "gbest_acc": 64.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348208,
+ "gbest_acc": 64.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.344182,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.333562,
+ "gbest_acc": 62.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.325619,
+ "gbest_acc": 61.8,
+ "val_loss": 1.338582,
+ "val_acc": 62.87
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.324816,
+ "gbest_acc": 63.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.323064,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.314797,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.308174,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.291646,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.28531,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.28531,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.28531,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.272941,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.272941,
+ "gbest_acc": 64.45,
+ "val_loss": 1.285351,
+ "val_acc": 63.67
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.268151,
+ "gbest_acc": 63.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.263173,
+ "gbest_acc": 64.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.262668,
+ "gbest_acc": 64.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.258032,
+ "gbest_acc": 65.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.258032,
+ "gbest_acc": 65.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.249328,
+ "gbest_acc": 65.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.235978,
+ "gbest_acc": 66.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.232522,
+ "gbest_acc": 65.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.225554,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.225554,
+ "gbest_acc": 66.3,
+ "val_loss": 1.244672,
+ "val_acc": 65.28
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.225076,
+ "gbest_acc": 66.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.216084,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.216084,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.216084,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.212699,
+ "gbest_acc": 66.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.209075,
+ "gbest_acc": 66.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.205777,
+ "gbest_acc": 67.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.203133,
+ "gbest_acc": 67.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.196253,
+ "gbest_acc": 67.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.196253,
+ "gbest_acc": 67.2,
+ "val_loss": 1.213984,
+ "val_acc": 66.04
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.191978,
+ "gbest_acc": 68.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.191814,
+ "gbest_acc": 68.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.188008,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.188008,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.186632,
+ "gbest_acc": 67.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.174344,
+ "gbest_acc": 67.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.174344,
+ "gbest_acc": 67.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172305,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.168621,
+ "gbest_acc": 67.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.168621,
+ "gbest_acc": 67.75,
+ "val_loss": 1.183569,
+ "val_acc": 66.47
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.168621,
+ "gbest_acc": 67.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.159108,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.153097,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.147897,
+ "gbest_acc": 67.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.143562,
+ "gbest_acc": 67.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.133717,
+ "gbest_acc": 68.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.133275,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.133275,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132648,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132415,
+ "gbest_acc": 68.1,
+ "val_loss": 1.150517,
+ "val_acc": 66.83
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.130736,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.125353,
+ "gbest_acc": 68.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.125353,
+ "gbest_acc": 68.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12407,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.121807,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.120392,
+ "gbest_acc": 68.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.114197,
+ "gbest_acc": 68.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.111764,
+ "gbest_acc": 68.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.108939,
+ "gbest_acc": 69.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.099831,
+ "gbest_acc": 69.1,
+ "val_loss": 1.118862,
+ "val_acc": 68.14
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.094812,
+ "gbest_acc": 70.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.089858,
+ "gbest_acc": 69.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.089602,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.089602,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.089602,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.085394,
+ "gbest_acc": 70.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.084047,
+ "gbest_acc": 70.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.08141,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.08141,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.077731,
+ "gbest_acc": 69.95,
+ "val_loss": 1.098037,
+ "val_acc": 69.04
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.072367,
+ "gbest_acc": 70.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.063682,
+ "gbest_acc": 70.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057554,
+ "gbest_acc": 71.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057554,
+ "gbest_acc": 71.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.053368,
+ "gbest_acc": 70.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.051527,
+ "gbest_acc": 71.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.047009,
+ "gbest_acc": 72.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.041935,
+ "gbest_acc": 70.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.041043,
+ "gbest_acc": 72.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.041043,
+ "gbest_acc": 72.0,
+ "val_loss": 1.05923,
+ "val_acc": 70.19
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.035393,
+ "gbest_acc": 71.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.035193,
+ "gbest_acc": 71.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.027319,
+ "gbest_acc": 71.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.022736,
+ "gbest_acc": 72.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.019489,
+ "gbest_acc": 71.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.019124,
+ "gbest_acc": 72.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.018566,
+ "gbest_acc": 71.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.015584,
+ "gbest_acc": 71.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.010838,
+ "gbest_acc": 73.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.000518,
+ "gbest_acc": 73.65,
+ "val_loss": 1.024892,
+ "val_acc": 71.89
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.998748,
+ "gbest_acc": 73.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.99365,
+ "gbest_acc": 73.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.992853,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.992536,
+ "gbest_acc": 73.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.989249,
+ "gbest_acc": 73.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.985433,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.975649,
+ "gbest_acc": 73.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974206,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.969716,
+ "gbest_acc": 74.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.966226,
+ "gbest_acc": 74.15,
+ "val_loss": 0.985178,
+ "val_acc": 72.82
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.963654,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.957999,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.957999,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.957999,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.957999,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.957999,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.954653,
+ "gbest_acc": 73.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.953383,
+ "gbest_acc": 73.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.950293,
+ "gbest_acc": 73.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.944131,
+ "gbest_acc": 73.95,
+ "val_loss": 0.964191,
+ "val_acc": 72.58
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.944131,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.944131,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.943785,
+ "gbest_acc": 74.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.938597,
+ "gbest_acc": 74.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.935632,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.935632,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.935399,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.934856,
+ "gbest_acc": 74.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.923794,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.923794,
+ "gbest_acc": 75.4,
+ "val_loss": 0.945008,
+ "val_acc": 73.97
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.923794,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.922926,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.917747,
+ "gbest_acc": 75.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.914712,
+ "gbest_acc": 75.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.914712,
+ "gbest_acc": 75.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.914712,
+ "gbest_acc": 75.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.913753,
+ "gbest_acc": 76.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.912153,
+ "gbest_acc": 75.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.907952,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.907952,
+ "gbest_acc": 75.35,
+ "val_loss": 0.931234,
+ "val_acc": 73.97
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.907952,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.907587,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.904635,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.90148,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.90148,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.8979,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.896573,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.896172,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.891362,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.890303,
+ "gbest_acc": 74.9,
+ "val_loss": 0.913331,
+ "val_acc": 74.39
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884626,
+ "gbest_acc": 74.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884327,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884327,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884327,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.883291,
+ "gbest_acc": 75.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.881202,
+ "gbest_acc": 75.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.880811,
+ "gbest_acc": 75.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.880326,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.877519,
+ "gbest_acc": 75.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.877405,
+ "gbest_acc": 75.15,
+ "val_loss": 0.900336,
+ "val_acc": 74.99
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.877238,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.876437,
+ "gbest_acc": 74.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.876437,
+ "gbest_acc": 74.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875141,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871409,
+ "gbest_acc": 75.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871409,
+ "gbest_acc": 75.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.870908,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.864695,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.864695,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.864631,
+ "gbest_acc": 75.7,
+ "val_loss": 0.88956,
+ "val_acc": 75.01
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.86268,
+ "gbest_acc": 75.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.861083,
+ "gbest_acc": 76.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.860286,
+ "gbest_acc": 76.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.857634,
+ "gbest_acc": 76.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.852978,
+ "gbest_acc": 76.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.852641,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.8512,
+ "gbest_acc": 76.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849907,
+ "gbest_acc": 76.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849907,
+ "gbest_acc": 76.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.847881,
+ "gbest_acc": 76.4,
+ "val_loss": 0.872274,
+ "val_acc": 75.6
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.847881,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.847119,
+ "gbest_acc": 76.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.846274,
+ "gbest_acc": 76.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.846046,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.845023,
+ "gbest_acc": 76.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840576,
+ "gbest_acc": 76.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840576,
+ "gbest_acc": 76.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.839159,
+ "gbest_acc": 77.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.83752,
+ "gbest_acc": 77.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.835964,
+ "gbest_acc": 77.2,
+ "val_loss": 0.860244,
+ "val_acc": 76.0
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.83472,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.833305,
+ "gbest_acc": 77.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.833305,
+ "gbest_acc": 77.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.830545,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.830545,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.830255,
+ "gbest_acc": 77.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.829839,
+ "gbest_acc": 77.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.82889,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.826404,
+ "gbest_acc": 77.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.826404,
+ "gbest_acc": 77.35,
+ "val_loss": 0.846733,
+ "val_acc": 76.49
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.825203,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.822632,
+ "gbest_acc": 77.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821505,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.819901,
+ "gbest_acc": 77.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.81959,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.818747,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.817012,
+ "gbest_acc": 77.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.816612,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.816612,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.815692,
+ "gbest_acc": 77.15,
+ "val_loss": 0.837387,
+ "val_acc": 76.5
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.814846,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.814846,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.813985,
+ "gbest_acc": 77.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.812232,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.81218,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.811889,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.810623,
+ "gbest_acc": 77.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.810184,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.808774,
+ "gbest_acc": 78.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.808023,
+ "gbest_acc": 77.95,
+ "val_loss": 0.830918,
+ "val_acc": 76.67
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.80682,
+ "gbest_acc": 78.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.805953,
+ "gbest_acc": 77.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.803392,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.801801,
+ "gbest_acc": 78.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.801801,
+ "gbest_acc": 78.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.798786,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.797544,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.796106,
+ "gbest_acc": 78.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.795623,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.794693,
+ "gbest_acc": 77.85,
+ "val_loss": 0.817966,
+ "val_acc": 77.13
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.794693,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.794693,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.794478,
+ "gbest_acc": 78.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.793215,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.791388,
+ "gbest_acc": 78.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.790408,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.789418,
+ "gbest_acc": 78.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.789202,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.788594,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.788055,
+ "gbest_acc": 78.35,
+ "val_loss": 0.811334,
+ "val_acc": 77.58
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.786868,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.786868,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.786868,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.785116,
+ "gbest_acc": 78.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.783393,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.781453,
+ "gbest_acc": 78.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.780071,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.778294,
+ "gbest_acc": 78.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.776726,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.775377,
+ "gbest_acc": 77.55,
+ "val_loss": 0.795441,
+ "val_acc": 77.28
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.774969,
+ "gbest_acc": 78.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.772238,
+ "gbest_acc": 78.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.772039,
+ "gbest_acc": 78.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.769885,
+ "gbest_acc": 78.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.769478,
+ "gbest_acc": 78.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.768498,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.767502,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.767502,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.767133,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.767133,
+ "gbest_acc": 78.75,
+ "val_loss": 0.788033,
+ "val_acc": 77.5
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.765102,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.763933,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.763474,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.762153,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.762142,
+ "gbest_acc": 78.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.761141,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.761081,
+ "gbest_acc": 78.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.760497,
+ "gbest_acc": 78.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758616,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758616,
+ "gbest_acc": 78.35,
+ "val_loss": 0.779411,
+ "val_acc": 77.75
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.75746,
+ "gbest_acc": 78.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.756612,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.756612,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.756549,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.755589,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.754062,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.752592,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.75118,
+ "gbest_acc": 79.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.749815,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.749518,
+ "gbest_acc": 79.05,
+ "val_loss": 0.773585,
+ "val_acc": 78.13
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.748701,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.748321,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.746875,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.746404,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.745172,
+ "gbest_acc": 79.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743821,
+ "gbest_acc": 79.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743731,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743297,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74163,
+ "gbest_acc": 79.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74163,
+ "gbest_acc": 79.4,
+ "val_loss": 0.763832,
+ "val_acc": 78.42
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74045,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.739238,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.738549,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.738549,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.738082,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.738082,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.736419,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735464,
+ "gbest_acc": 79.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.734945,
+ "gbest_acc": 79.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.734439,
+ "gbest_acc": 78.75,
+ "val_loss": 0.758619,
+ "val_acc": 78.29
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.733979,
+ "gbest_acc": 78.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.732861,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.731852,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.730788,
+ "gbest_acc": 78.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.729284,
+ "gbest_acc": 78.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727606,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.724911,
+ "gbest_acc": 78.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721989,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721166,
+ "gbest_acc": 79.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.718883,
+ "gbest_acc": 79.7,
+ "val_loss": 0.744017,
+ "val_acc": 78.77
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.716488,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.714843,
+ "gbest_acc": 79.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.714411,
+ "gbest_acc": 79.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.714411,
+ "gbest_acc": 79.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.712479,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.711541,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.710939,
+ "gbest_acc": 79.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.709965,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.707764,
+ "gbest_acc": 79.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.707764,
+ "gbest_acc": 79.7,
+ "val_loss": 0.734293,
+ "val_acc": 78.95
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.707728,
+ "gbest_acc": 79.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705958,
+ "gbest_acc": 79.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705958,
+ "gbest_acc": 79.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705929,
+ "gbest_acc": 79.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705038,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703885,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.702624,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.701274,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.700996,
+ "gbest_acc": 79.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.698876,
+ "gbest_acc": 79.3,
+ "val_loss": 0.723231,
+ "val_acc": 79.16
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.697683,
+ "gbest_acc": 79.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.697236,
+ "gbest_acc": 79.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696473,
+ "gbest_acc": 79.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693805,
+ "gbest_acc": 80.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693117,
+ "gbest_acc": 80.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.692481,
+ "gbest_acc": 79.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.692026,
+ "gbest_acc": 80.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.692026,
+ "gbest_acc": 80.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.69118,
+ "gbest_acc": 79.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.689941,
+ "gbest_acc": 80.05,
+ "val_loss": 0.712515,
+ "val_acc": 79.53
+ }
+ ],
+ "seed": 103,
+ "geometry_config": {
+ "config_id": "G1",
+ "scale_type": "global_rms",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate anisotropic per-tensor scaling"
+ }
+ }
+ ],
+ "G8": [
+ {
+ "config_id": "G8",
+ "gbest_loss": 0.385086,
+ "gbest_acc": 88.8,
+ "val_selected_loss": 0.492543,
+ "val_selected_acc": 84.47,
+ "val_metrics": {
+ "accuracy": 84.47,
+ "nll": 0.492543,
+ "brier": 0.226311,
+ "ece": 0.006948,
+ "margin": 0.74696
+ },
+ "wall_time_sec": 47.8347,
+ "optimization_wall_time_sec": 46.6915,
+ "validation_wall_time_sec": 1.1431,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 61,
+ "official_test_evaluations": 0,
+ "pbest_update_counts": 0,
+ "boundary_hits": 0,
+ "boundary_occupancy": 0.0,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.0,
+ "position_radius": 0.0,
+ "stage_histories": [],
+ "seed": 101,
+ "geometry_config": {
+ "config_id": "G8",
+ "scale_type": "optimizer_default",
+ "init_position_mode": "independent",
+ "position_radius": 0.05,
+ "initial_velocity_radius": 0.05,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "retained semantic control (public Optimizer)"
+ }
+ },
+ {
+ "config_id": "G8",
+ "gbest_loss": 0.298761,
+ "gbest_acc": 90.7,
+ "val_selected_loss": 0.448056,
+ "val_selected_acc": 86.05,
+ "val_metrics": {
+ "accuracy": 86.05,
+ "nll": 0.448056,
+ "brier": 0.206991,
+ "ece": 0.020049,
+ "margin": 0.798482
+ },
+ "wall_time_sec": 45.4033,
+ "optimization_wall_time_sec": 44.8804,
+ "validation_wall_time_sec": 0.5229,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 61,
+ "official_test_evaluations": 0,
+ "pbest_update_counts": 0,
+ "boundary_hits": 0,
+ "boundary_occupancy": 0.0,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.0,
+ "position_radius": 0.0,
+ "stage_histories": [],
+ "seed": 102,
+ "geometry_config": {
+ "config_id": "G8",
+ "scale_type": "optimizer_default",
+ "init_position_mode": "independent",
+ "position_radius": 0.05,
+ "initial_velocity_radius": 0.05,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "retained semantic control (public Optimizer)"
+ }
+ },
+ {
+ "config_id": "G8",
+ "gbest_loss": 0.437193,
+ "gbest_acc": 86.8,
+ "val_selected_loss": 0.503722,
+ "val_selected_acc": 84.23,
+ "val_metrics": {
+ "accuracy": 84.23,
+ "nll": 0.503722,
+ "brier": 0.23026,
+ "ece": 0.01607,
+ "margin": 0.723439
+ },
+ "wall_time_sec": 49.9031,
+ "optimization_wall_time_sec": 49.3871,
+ "validation_wall_time_sec": 0.516,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 61,
+ "official_test_evaluations": 0,
+ "pbest_update_counts": 0,
+ "boundary_hits": 0,
+ "boundary_occupancy": 0.0,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.0,
+ "position_radius": 0.0,
+ "stage_histories": [],
+ "seed": 103,
+ "geometry_config": {
+ "config_id": "G8",
+ "scale_type": "optimizer_default",
+ "init_position_mode": "independent",
+ "position_radius": 0.05,
+ "initial_velocity_radius": 0.05,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "retained semantic control (public Optimizer)"
+ }
+ }
+ ],
+ "G5": [
+ {
+ "config_id": "G5",
+ "gbest_loss": 0.369503,
+ "gbest_acc": 89.4,
+ "gbest_val_loss": 0.486263,
+ "gbest_val_acc": 84.93,
+ "val_selected_particle_idx": 35,
+ "val_selected_loss": 0.482174,
+ "val_selected_acc": 85.28,
+ "val_metrics": {
+ "accuracy": 85.28,
+ "nll": 0.482174,
+ "brier": 0.219081,
+ "ece": 0.008102,
+ "margin": 0.754631
+ },
+ "wall_time_sec": 32.9311,
+ "optimization_wall_time_sec": 32.5085,
+ "validation_wall_time_sec": 0.4226,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 467,
+ "final_moment_steps": [
+ 9,
+ 72,
+ 16,
+ 171,
+ 84,
+ 155,
+ 102,
+ 104,
+ 19,
+ 2,
+ 90,
+ 29,
+ 50,
+ 63,
+ 143,
+ 10,
+ 99,
+ 39,
+ 87,
+ 27,
+ 5,
+ 7,
+ 27,
+ 8,
+ 11,
+ 5,
+ 12,
+ 26,
+ 8,
+ 49,
+ 55,
+ 80,
+ 93,
+ 40,
+ 13,
+ 7,
+ 7,
+ 15,
+ 73,
+ 1,
+ 54,
+ 239,
+ 76,
+ 33,
+ 6,
+ 21,
+ 56,
+ 28,
+ 4,
+ 1,
+ 25,
+ 88,
+ 115,
+ 60,
+ 8,
+ 129,
+ 13,
+ 53,
+ 19,
+ 11
+ ],
+ "pbest_update_counts": 10708,
+ "boundary_hits": 262583,
+ "boundary_occupancy": 0.001145,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.120612,
+ "position_radius": 9.116757,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.313677,
+ "gbest_acc": 8.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.298876,
+ "gbest_acc": 9.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.278552,
+ "gbest_acc": 12.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.264536,
+ "gbest_acc": 13.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.229959,
+ "gbest_acc": 17.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.184555,
+ "gbest_acc": 17.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.117779,
+ "gbest_acc": 23.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.087162,
+ "gbest_acc": 23.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.027791,
+ "gbest_acc": 26.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.000861,
+ "gbest_acc": 28.25,
+ "val_loss": 2.024861,
+ "val_acc": 26.39
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.957443,
+ "gbest_acc": 26.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.916278,
+ "gbest_acc": 31.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.903273,
+ "gbest_acc": 31.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.884541,
+ "gbest_acc": 31.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.842811,
+ "gbest_acc": 35.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.809725,
+ "gbest_acc": 35.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.802479,
+ "gbest_acc": 34.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.727687,
+ "gbest_acc": 39.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.701846,
+ "gbest_acc": 40.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.694906,
+ "gbest_acc": 41.95,
+ "val_loss": 1.72126,
+ "val_acc": 41.38
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.646171,
+ "gbest_acc": 43.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.640748,
+ "gbest_acc": 43.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.626077,
+ "gbest_acc": 44.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.620746,
+ "gbest_acc": 45.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.593086,
+ "gbest_acc": 45.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.583507,
+ "gbest_acc": 48.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566582,
+ "gbest_acc": 46.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.563556,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.562349,
+ "gbest_acc": 45.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.536205,
+ "gbest_acc": 48.8,
+ "val_loss": 1.55558,
+ "val_acc": 47.8
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.519785,
+ "gbest_acc": 48.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.519785,
+ "gbest_acc": 48.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.519785,
+ "gbest_acc": 48.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.507749,
+ "gbest_acc": 49.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.481671,
+ "gbest_acc": 49.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.443953,
+ "gbest_acc": 49.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.443953,
+ "gbest_acc": 49.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.41154,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.41154,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.41154,
+ "gbest_acc": 51.35,
+ "val_loss": 1.467953,
+ "val_acc": 48.57
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.41154,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.368685,
+ "gbest_acc": 52.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.35309,
+ "gbest_acc": 54.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.342129,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.329453,
+ "gbest_acc": 55.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.322546,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.322546,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.322546,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.322546,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.307902,
+ "gbest_acc": 55.95,
+ "val_loss": 1.343455,
+ "val_acc": 54.87
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.273758,
+ "gbest_acc": 56.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.273758,
+ "gbest_acc": 56.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.264488,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.259814,
+ "gbest_acc": 56.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.257108,
+ "gbest_acc": 56.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.201708,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.201708,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.201708,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.198806,
+ "gbest_acc": 60.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177065,
+ "gbest_acc": 62.4,
+ "val_loss": 1.212465,
+ "val_acc": 60.09
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177065,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.154394,
+ "gbest_acc": 62.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.150699,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.150699,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146757,
+ "gbest_acc": 62.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.127421,
+ "gbest_acc": 63.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.126285,
+ "gbest_acc": 63.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.118984,
+ "gbest_acc": 63.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.118984,
+ "gbest_acc": 63.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.118984,
+ "gbest_acc": 63.05,
+ "val_loss": 1.156018,
+ "val_acc": 61.68
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.118984,
+ "gbest_acc": 63.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106567,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.080883,
+ "gbest_acc": 65.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.065373,
+ "gbest_acc": 64.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.056323,
+ "gbest_acc": 65.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.056323,
+ "gbest_acc": 65.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.053468,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.053468,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.053322,
+ "gbest_acc": 65.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.050174,
+ "gbest_acc": 65.5,
+ "val_loss": 1.088162,
+ "val_acc": 63.98
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.042139,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.03333,
+ "gbest_acc": 67.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.031238,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.031238,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023848,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.021024,
+ "gbest_acc": 67.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.007964,
+ "gbest_acc": 67.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.005775,
+ "gbest_acc": 67.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.998774,
+ "gbest_acc": 67.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.98712,
+ "gbest_acc": 67.95,
+ "val_loss": 1.022042,
+ "val_acc": 66.11
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.982986,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.982986,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.977766,
+ "gbest_acc": 69.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.9642,
+ "gbest_acc": 69.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.9642,
+ "gbest_acc": 69.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.9642,
+ "gbest_acc": 69.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.956048,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.954685,
+ "gbest_acc": 69.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.93815,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.933452,
+ "gbest_acc": 69.55,
+ "val_loss": 0.982123,
+ "val_acc": 67.41
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.933452,
+ "gbest_acc": 69.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.933452,
+ "gbest_acc": 69.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.928255,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.924551,
+ "gbest_acc": 71.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.924551,
+ "gbest_acc": 71.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.924551,
+ "gbest_acc": 71.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.915148,
+ "gbest_acc": 71.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.915148,
+ "gbest_acc": 71.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.908145,
+ "gbest_acc": 71.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.907067,
+ "gbest_acc": 69.7,
+ "val_loss": 0.960846,
+ "val_acc": 68.01
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.902756,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.897202,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.885313,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.885313,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.885313,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.885313,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.885313,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.880794,
+ "gbest_acc": 72.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.880794,
+ "gbest_acc": 72.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.880794,
+ "gbest_acc": 72.15,
+ "val_loss": 0.926605,
+ "val_acc": 69.29
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.880794,
+ "gbest_acc": 72.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.872636,
+ "gbest_acc": 72.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.8654,
+ "gbest_acc": 72.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.864818,
+ "gbest_acc": 71.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.853998,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.852847,
+ "gbest_acc": 72.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.841039,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.841039,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.841039,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840294,
+ "gbest_acc": 73.35,
+ "val_loss": 0.903008,
+ "val_acc": 70.83
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.825337,
+ "gbest_acc": 73.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821023,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821023,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821023,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.821023,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.818559,
+ "gbest_acc": 74.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.811456,
+ "gbest_acc": 74.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.807997,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.803719,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.803625,
+ "gbest_acc": 74.5,
+ "val_loss": 0.862754,
+ "val_acc": 72.01
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.795814,
+ "gbest_acc": 74.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.791245,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.791245,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.791028,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.788966,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.781821,
+ "gbest_acc": 74.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.779152,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.77104,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.766927,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.766927,
+ "gbest_acc": 75.3,
+ "val_loss": 0.826319,
+ "val_acc": 73.13
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.766272,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.759929,
+ "gbest_acc": 75.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758941,
+ "gbest_acc": 74.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.750904,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.747482,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74011,
+ "gbest_acc": 75.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.733568,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.733568,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.733568,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.731425,
+ "gbest_acc": 75.4,
+ "val_loss": 0.803664,
+ "val_acc": 73.95
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727226,
+ "gbest_acc": 76.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.726697,
+ "gbest_acc": 76.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.723895,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.723895,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.722701,
+ "gbest_acc": 76.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.71915,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.715992,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.713979,
+ "gbest_acc": 76.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.71334,
+ "gbest_acc": 76.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.711599,
+ "gbest_acc": 76.7,
+ "val_loss": 0.781023,
+ "val_acc": 74.9
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.705004,
+ "gbest_acc": 77.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.701269,
+ "gbest_acc": 76.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696262,
+ "gbest_acc": 76.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.694294,
+ "gbest_acc": 76.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.691105,
+ "gbest_acc": 76.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.6872,
+ "gbest_acc": 76.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.681538,
+ "gbest_acc": 76.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.6793,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.674095,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.672578,
+ "gbest_acc": 77.4,
+ "val_loss": 0.741742,
+ "val_acc": 75.88
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.666917,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.666917,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.665581,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.660297,
+ "gbest_acc": 78.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.660297,
+ "gbest_acc": 78.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.659515,
+ "gbest_acc": 78.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.654813,
+ "gbest_acc": 78.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.649778,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.649778,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.649391,
+ "gbest_acc": 78.3,
+ "val_loss": 0.7235,
+ "val_acc": 76.44
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.648711,
+ "gbest_acc": 78.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.645988,
+ "gbest_acc": 78.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.644148,
+ "gbest_acc": 78.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.642658,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.640317,
+ "gbest_acc": 79.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.636775,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.635216,
+ "gbest_acc": 78.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.633089,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.631302,
+ "gbest_acc": 79.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.62756,
+ "gbest_acc": 79.4,
+ "val_loss": 0.704798,
+ "val_acc": 77.65
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.62519,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.62519,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.623713,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.621676,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.619235,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.619235,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.619235,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.617317,
+ "gbest_acc": 80.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.611875,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.611386,
+ "gbest_acc": 80.05,
+ "val_loss": 0.697042,
+ "val_acc": 77.85
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.608487,
+ "gbest_acc": 80.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.60426,
+ "gbest_acc": 81.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.599621,
+ "gbest_acc": 80.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.59565,
+ "gbest_acc": 81.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.591675,
+ "gbest_acc": 80.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.588267,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.584099,
+ "gbest_acc": 81.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.583183,
+ "gbest_acc": 81.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.580294,
+ "gbest_acc": 81.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.580294,
+ "gbest_acc": 81.45,
+ "val_loss": 0.665134,
+ "val_acc": 78.72
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.580294,
+ "gbest_acc": 81.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.578382,
+ "gbest_acc": 81.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.576433,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.576433,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.5744,
+ "gbest_acc": 81.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.571134,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.566484,
+ "gbest_acc": 82.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.566484,
+ "gbest_acc": 82.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.566484,
+ "gbest_acc": 82.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.563107,
+ "gbest_acc": 82.4,
+ "val_loss": 0.654681,
+ "val_acc": 79.04
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.561057,
+ "gbest_acc": 82.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.560716,
+ "gbest_acc": 82.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.559278,
+ "gbest_acc": 82.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.556142,
+ "gbest_acc": 82.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.556142,
+ "gbest_acc": 82.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.5561,
+ "gbest_acc": 82.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.552555,
+ "gbest_acc": 82.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.551543,
+ "gbest_acc": 82.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.551543,
+ "gbest_acc": 82.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.550248,
+ "gbest_acc": 82.9,
+ "val_loss": 0.644208,
+ "val_acc": 79.58
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.54678,
+ "gbest_acc": 83.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.545932,
+ "gbest_acc": 83.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.544068,
+ "gbest_acc": 82.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.540955,
+ "gbest_acc": 82.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.536781,
+ "gbest_acc": 83.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.536781,
+ "gbest_acc": 83.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.536781,
+ "gbest_acc": 83.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.533209,
+ "gbest_acc": 83.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.531294,
+ "gbest_acc": 83.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.530024,
+ "gbest_acc": 83.25,
+ "val_loss": 0.632598,
+ "val_acc": 79.96
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.528,
+ "gbest_acc": 83.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.526719,
+ "gbest_acc": 83.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.526629,
+ "gbest_acc": 83.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.526629,
+ "gbest_acc": 83.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.524434,
+ "gbest_acc": 83.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.522196,
+ "gbest_acc": 84.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.522196,
+ "gbest_acc": 84.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.519136,
+ "gbest_acc": 84.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.519136,
+ "gbest_acc": 84.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.516824,
+ "gbest_acc": 84.05,
+ "val_loss": 0.612846,
+ "val_acc": 80.8
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.516824,
+ "gbest_acc": 84.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.5152,
+ "gbest_acc": 84.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.512375,
+ "gbest_acc": 84.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.512375,
+ "gbest_acc": 84.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.512058,
+ "gbest_acc": 84.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.509873,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.509372,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.508474,
+ "gbest_acc": 84.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.507576,
+ "gbest_acc": 84.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.506051,
+ "gbest_acc": 84.95,
+ "val_loss": 0.603519,
+ "val_acc": 81.07
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.506051,
+ "gbest_acc": 84.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.505206,
+ "gbest_acc": 85.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.50499,
+ "gbest_acc": 84.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.502614,
+ "gbest_acc": 84.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.502614,
+ "gbest_acc": 84.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.502614,
+ "gbest_acc": 84.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.501009,
+ "gbest_acc": 84.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.497235,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.496154,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.492171,
+ "gbest_acc": 85.45,
+ "val_loss": 0.586684,
+ "val_acc": 81.63
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.492171,
+ "gbest_acc": 85.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.491467,
+ "gbest_acc": 85.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.490683,
+ "gbest_acc": 85.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.48889,
+ "gbest_acc": 85.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.487687,
+ "gbest_acc": 85.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.486713,
+ "gbest_acc": 85.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.484857,
+ "gbest_acc": 85.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.483942,
+ "gbest_acc": 84.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.481513,
+ "gbest_acc": 84.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.480071,
+ "gbest_acc": 84.8,
+ "val_loss": 0.579558,
+ "val_acc": 81.8
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.478504,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.476889,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.474502,
+ "gbest_acc": 85.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.472785,
+ "gbest_acc": 85.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.472693,
+ "gbest_acc": 85.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.471922,
+ "gbest_acc": 85.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.470094,
+ "gbest_acc": 85.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.469231,
+ "gbest_acc": 85.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.468381,
+ "gbest_acc": 85.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.467715,
+ "gbest_acc": 85.4,
+ "val_loss": 0.56837,
+ "val_acc": 82.25
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.465616,
+ "gbest_acc": 85.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.463932,
+ "gbest_acc": 85.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.463625,
+ "gbest_acc": 85.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.461318,
+ "gbest_acc": 85.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.459352,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45798,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.456746,
+ "gbest_acc": 86.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.456182,
+ "gbest_acc": 86.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45472,
+ "gbest_acc": 86.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.452741,
+ "gbest_acc": 86.5,
+ "val_loss": 0.55657,
+ "val_acc": 82.78
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.451112,
+ "gbest_acc": 86.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.449722,
+ "gbest_acc": 86.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.449424,
+ "gbest_acc": 86.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.448278,
+ "gbest_acc": 86.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.447567,
+ "gbest_acc": 86.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.444713,
+ "gbest_acc": 86.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.44323,
+ "gbest_acc": 86.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.442631,
+ "gbest_acc": 86.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.44037,
+ "gbest_acc": 87.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.44037,
+ "gbest_acc": 87.15,
+ "val_loss": 0.547158,
+ "val_acc": 83.09
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.44037,
+ "gbest_acc": 87.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.440225,
+ "gbest_acc": 87.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.439287,
+ "gbest_acc": 86.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.439287,
+ "gbest_acc": 86.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.439287,
+ "gbest_acc": 86.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.437987,
+ "gbest_acc": 87.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.437205,
+ "gbest_acc": 86.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.436178,
+ "gbest_acc": 86.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.436178,
+ "gbest_acc": 86.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.436178,
+ "gbest_acc": 86.6,
+ "val_loss": 0.540593,
+ "val_acc": 83.41
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.433762,
+ "gbest_acc": 87.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.432071,
+ "gbest_acc": 87.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.43179,
+ "gbest_acc": 87.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.430514,
+ "gbest_acc": 87.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.430514,
+ "gbest_acc": 87.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.429056,
+ "gbest_acc": 87.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.428118,
+ "gbest_acc": 87.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.426461,
+ "gbest_acc": 87.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.425527,
+ "gbest_acc": 87.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.424084,
+ "gbest_acc": 87.45,
+ "val_loss": 0.529621,
+ "val_acc": 83.72
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.423104,
+ "gbest_acc": 87.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.421971,
+ "gbest_acc": 87.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.420597,
+ "gbest_acc": 87.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.420049,
+ "gbest_acc": 87.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.419632,
+ "gbest_acc": 87.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.418263,
+ "gbest_acc": 87.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.417817,
+ "gbest_acc": 87.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.417254,
+ "gbest_acc": 87.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.417062,
+ "gbest_acc": 87.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.414835,
+ "gbest_acc": 87.25,
+ "val_loss": 0.51885,
+ "val_acc": 83.88
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.414217,
+ "gbest_acc": 87.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.413432,
+ "gbest_acc": 87.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.412704,
+ "gbest_acc": 87.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.412391,
+ "gbest_acc": 87.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.411681,
+ "gbest_acc": 87.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.408864,
+ "gbest_acc": 87.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.408451,
+ "gbest_acc": 87.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.407069,
+ "gbest_acc": 87.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.405679,
+ "gbest_acc": 87.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.405679,
+ "gbest_acc": 87.5,
+ "val_loss": 0.514914,
+ "val_acc": 84.14
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.404874,
+ "gbest_acc": 87.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.404512,
+ "gbest_acc": 87.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.404279,
+ "gbest_acc": 87.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.403155,
+ "gbest_acc": 87.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.402961,
+ "gbest_acc": 87.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.401895,
+ "gbest_acc": 87.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.401762,
+ "gbest_acc": 87.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.401088,
+ "gbest_acc": 87.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.401088,
+ "gbest_acc": 87.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.401088,
+ "gbest_acc": 87.75,
+ "val_loss": 0.504588,
+ "val_acc": 84.68
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.399931,
+ "gbest_acc": 87.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.399931,
+ "gbest_acc": 87.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.398123,
+ "gbest_acc": 87.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.397103,
+ "gbest_acc": 87.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.396734,
+ "gbest_acc": 87.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.395385,
+ "gbest_acc": 87.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.395035,
+ "gbest_acc": 88.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.393996,
+ "gbest_acc": 88.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.393844,
+ "gbest_acc": 88.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.390816,
+ "gbest_acc": 88.2,
+ "val_loss": 0.504378,
+ "val_acc": 84.73
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.390816,
+ "gbest_acc": 88.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.390816,
+ "gbest_acc": 88.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.390654,
+ "gbest_acc": 88.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.390114,
+ "gbest_acc": 87.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.388685,
+ "gbest_acc": 87.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.388685,
+ "gbest_acc": 87.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.388685,
+ "gbest_acc": 87.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.38768,
+ "gbest_acc": 88.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.38768,
+ "gbest_acc": 88.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.38768,
+ "gbest_acc": 88.1,
+ "val_loss": 0.495703,
+ "val_acc": 84.86
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.387074,
+ "gbest_acc": 88.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.387074,
+ "gbest_acc": 88.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.387074,
+ "gbest_acc": 88.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.387074,
+ "gbest_acc": 88.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.386418,
+ "gbest_acc": 87.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.38485,
+ "gbest_acc": 88.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.383527,
+ "gbest_acc": 88.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.383527,
+ "gbest_acc": 88.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.383527,
+ "gbest_acc": 88.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.382249,
+ "gbest_acc": 88.65,
+ "val_loss": 0.495909,
+ "val_acc": 84.69
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.382249,
+ "gbest_acc": 88.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.382249,
+ "gbest_acc": 88.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.382249,
+ "gbest_acc": 88.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.381982,
+ "gbest_acc": 88.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.381982,
+ "gbest_acc": 88.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.381161,
+ "gbest_acc": 88.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.379115,
+ "gbest_acc": 88.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.379115,
+ "gbest_acc": 88.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.379115,
+ "gbest_acc": 88.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.379115,
+ "gbest_acc": 88.65,
+ "val_loss": 0.493146,
+ "val_acc": 84.81
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.378534,
+ "gbest_acc": 88.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.37783,
+ "gbest_acc": 88.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.375741,
+ "gbest_acc": 89.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.375625,
+ "gbest_acc": 89.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.374191,
+ "gbest_acc": 88.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.373528,
+ "gbest_acc": 89.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.37251,
+ "gbest_acc": 89.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.371197,
+ "gbest_acc": 89.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.37025,
+ "gbest_acc": 89.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.369503,
+ "gbest_acc": 89.4,
+ "val_loss": 0.486263,
+ "val_acc": 84.93
+ }
+ ],
+ "seed": 101,
+ "geometry_config": {
+ "config_id": "G5",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test sufficient bound expansion"
+ }
+ },
+ {
+ "config_id": "G5",
+ "gbest_loss": 0.435671,
+ "gbest_acc": 86.75,
+ "gbest_val_loss": 0.532956,
+ "gbest_val_acc": 83.79,
+ "val_selected_particle_idx": 56,
+ "val_selected_loss": 0.529533,
+ "val_selected_acc": 83.73,
+ "val_metrics": {
+ "accuracy": 83.73,
+ "nll": 0.529533,
+ "brier": 0.237264,
+ "ece": 0.012206,
+ "margin": 0.718737
+ },
+ "wall_time_sec": 32.9641,
+ "optimization_wall_time_sec": 32.5333,
+ "validation_wall_time_sec": 0.4308,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 513,
+ "final_moment_steps": [
+ 86,
+ 2,
+ 53,
+ 73,
+ 15,
+ 14,
+ 34,
+ 123,
+ 84,
+ 2,
+ 51,
+ 104,
+ 174,
+ 115,
+ 22,
+ 41,
+ 6,
+ 147,
+ 119,
+ 38,
+ 49,
+ 28,
+ 31,
+ 62,
+ 12,
+ 71,
+ 34,
+ 20,
+ 46,
+ 80,
+ 42,
+ 131,
+ 13,
+ 27,
+ 89,
+ 5,
+ 35,
+ 29,
+ 82,
+ 15,
+ 17,
+ 44,
+ 61,
+ 111,
+ 26,
+ 87,
+ 43,
+ 39,
+ 5,
+ 21,
+ 7,
+ 4,
+ 42,
+ 45,
+ 131,
+ 85,
+ 14,
+ 3,
+ 193,
+ 28
+ ],
+ "pbest_update_counts": 10003,
+ "boundary_hits": 149969,
+ "boundary_occupancy": 0.000654,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.100577,
+ "position_radius": 7.131938,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.314652,
+ "gbest_acc": 8.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.301145,
+ "gbest_acc": 8.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.285543,
+ "gbest_acc": 9.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.271624,
+ "gbest_acc": 15.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.253005,
+ "gbest_acc": 19.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.246552,
+ "gbest_acc": 20.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.227233,
+ "gbest_acc": 17.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.207625,
+ "gbest_acc": 16.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.182504,
+ "gbest_acc": 21.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.165681,
+ "gbest_acc": 22.35,
+ "val_loss": 2.1712,
+ "val_acc": 22.94
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.163023,
+ "gbest_acc": 24.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.103436,
+ "gbest_acc": 25.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.084129,
+ "gbest_acc": 24.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.062531,
+ "gbest_acc": 24.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.034178,
+ "gbest_acc": 26.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.02488,
+ "gbest_acc": 27.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.997893,
+ "gbest_acc": 29.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.961573,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.937211,
+ "gbest_acc": 33.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.927021,
+ "gbest_acc": 33.75,
+ "val_loss": 1.93514,
+ "val_acc": 34.83
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.906708,
+ "gbest_acc": 36.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.863046,
+ "gbest_acc": 38.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.831445,
+ "gbest_acc": 37.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.824408,
+ "gbest_acc": 38.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.811021,
+ "gbest_acc": 39.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.792484,
+ "gbest_acc": 38.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.781789,
+ "gbest_acc": 39.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.769389,
+ "gbest_acc": 44.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.753771,
+ "gbest_acc": 41.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.734722,
+ "gbest_acc": 43.95,
+ "val_loss": 1.757246,
+ "val_acc": 43.7
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.734722,
+ "gbest_acc": 43.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.697146,
+ "gbest_acc": 40.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.697146,
+ "gbest_acc": 40.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.697146,
+ "gbest_acc": 40.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.682826,
+ "gbest_acc": 42.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.682826,
+ "gbest_acc": 42.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.672931,
+ "gbest_acc": 44.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.672931,
+ "gbest_acc": 44.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.672931,
+ "gbest_acc": 44.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.65295,
+ "gbest_acc": 46.35,
+ "val_loss": 1.666945,
+ "val_acc": 46.48
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.637196,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.602009,
+ "gbest_acc": 44.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.602009,
+ "gbest_acc": 44.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.602009,
+ "gbest_acc": 44.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597236,
+ "gbest_acc": 45.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.574492,
+ "gbest_acc": 47.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.535161,
+ "gbest_acc": 52.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.528065,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.503107,
+ "gbest_acc": 54.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.471189,
+ "gbest_acc": 56.25,
+ "val_loss": 1.475851,
+ "val_acc": 54.38
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.461462,
+ "gbest_acc": 56.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.441362,
+ "gbest_acc": 56.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.434281,
+ "gbest_acc": 51.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.415905,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.415905,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.415059,
+ "gbest_acc": 58.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.404588,
+ "gbest_acc": 57.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388056,
+ "gbest_acc": 59.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.380641,
+ "gbest_acc": 60.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.363306,
+ "gbest_acc": 58.6,
+ "val_loss": 1.370271,
+ "val_acc": 58.06
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362694,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362694,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.339104,
+ "gbest_acc": 60.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.334277,
+ "gbest_acc": 57.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.325037,
+ "gbest_acc": 60.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.318799,
+ "gbest_acc": 61.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.303291,
+ "gbest_acc": 60.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.277527,
+ "gbest_acc": 61.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.277527,
+ "gbest_acc": 61.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.274515,
+ "gbest_acc": 62.25,
+ "val_loss": 1.291924,
+ "val_acc": 59.77
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.266792,
+ "gbest_acc": 62.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.263764,
+ "gbest_acc": 61.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240207,
+ "gbest_acc": 63.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.233122,
+ "gbest_acc": 63.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.229638,
+ "gbest_acc": 62.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.226272,
+ "gbest_acc": 62.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.22081,
+ "gbest_acc": 62.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.22081,
+ "gbest_acc": 62.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.203829,
+ "gbest_acc": 62.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.181536,
+ "gbest_acc": 63.6,
+ "val_loss": 1.207731,
+ "val_acc": 62.89
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172561,
+ "gbest_acc": 63.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172258,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.172258,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.168966,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.160746,
+ "gbest_acc": 63.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.153432,
+ "gbest_acc": 64.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.150546,
+ "gbest_acc": 65.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.138009,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.131097,
+ "gbest_acc": 64.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.127212,
+ "gbest_acc": 65.15,
+ "val_loss": 1.156661,
+ "val_acc": 63.2
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.121893,
+ "gbest_acc": 65.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.118445,
+ "gbest_acc": 65.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106491,
+ "gbest_acc": 65.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.101166,
+ "gbest_acc": 65.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.086662,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.078371,
+ "gbest_acc": 66.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.069283,
+ "gbest_acc": 67.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.064285,
+ "gbest_acc": 66.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.053834,
+ "gbest_acc": 67.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.049919,
+ "gbest_acc": 67.15,
+ "val_loss": 1.097226,
+ "val_acc": 64.86
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.045435,
+ "gbest_acc": 67.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.032757,
+ "gbest_acc": 67.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.026372,
+ "gbest_acc": 68.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.026372,
+ "gbest_acc": 68.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.026372,
+ "gbest_acc": 68.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.026372,
+ "gbest_acc": 68.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.016106,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.013769,
+ "gbest_acc": 68.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.013769,
+ "gbest_acc": 68.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.008562,
+ "gbest_acc": 68.65,
+ "val_loss": 1.050804,
+ "val_acc": 66.61
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.005835,
+ "gbest_acc": 69.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.000665,
+ "gbest_acc": 69.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.994682,
+ "gbest_acc": 69.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.994682,
+ "gbest_acc": 69.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993222,
+ "gbest_acc": 70.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993222,
+ "gbest_acc": 70.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.991108,
+ "gbest_acc": 70.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.985242,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.976371,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.976371,
+ "gbest_acc": 70.7,
+ "val_loss": 1.012804,
+ "val_acc": 68.31
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.973287,
+ "gbest_acc": 70.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967998,
+ "gbest_acc": 70.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.964034,
+ "gbest_acc": 71.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.956772,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.952415,
+ "gbest_acc": 70.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.949171,
+ "gbest_acc": 70.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.94739,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.939679,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.937849,
+ "gbest_acc": 70.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.930213,
+ "gbest_acc": 71.25,
+ "val_loss": 0.970888,
+ "val_acc": 69.38
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.929182,
+ "gbest_acc": 71.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.919365,
+ "gbest_acc": 71.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.915393,
+ "gbest_acc": 72.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.915393,
+ "gbest_acc": 72.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.913665,
+ "gbest_acc": 72.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.907464,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.907464,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.907464,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.902548,
+ "gbest_acc": 72.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.900902,
+ "gbest_acc": 72.5,
+ "val_loss": 0.941405,
+ "val_acc": 70.26
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.895649,
+ "gbest_acc": 72.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.893505,
+ "gbest_acc": 73.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.889665,
+ "gbest_acc": 73.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882502,
+ "gbest_acc": 73.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.877866,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.873132,
+ "gbest_acc": 73.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871767,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871767,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871626,
+ "gbest_acc": 73.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.86981,
+ "gbest_acc": 73.7,
+ "val_loss": 0.916952,
+ "val_acc": 71.08
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.860779,
+ "gbest_acc": 73.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858887,
+ "gbest_acc": 74.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.852279,
+ "gbest_acc": 73.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.841082,
+ "gbest_acc": 73.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.841082,
+ "gbest_acc": 73.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.841082,
+ "gbest_acc": 73.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.839542,
+ "gbest_acc": 73.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.835588,
+ "gbest_acc": 73.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.832255,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.827652,
+ "gbest_acc": 73.95,
+ "val_loss": 0.881246,
+ "val_acc": 72.06
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.822057,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.817162,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.815254,
+ "gbest_acc": 74.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.814348,
+ "gbest_acc": 74.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.814348,
+ "gbest_acc": 74.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.813445,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.805889,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.804227,
+ "gbest_acc": 75.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.801571,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.796149,
+ "gbest_acc": 74.95,
+ "val_loss": 0.846407,
+ "val_acc": 72.89
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.794131,
+ "gbest_acc": 74.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.785041,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.785041,
+ "gbest_acc": 75.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.775095,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.769389,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.76368,
+ "gbest_acc": 76.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.761992,
+ "gbest_acc": 76.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758262,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.753981,
+ "gbest_acc": 76.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.753981,
+ "gbest_acc": 76.7,
+ "val_loss": 0.807665,
+ "val_acc": 74.46
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.751734,
+ "gbest_acc": 76.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.748355,
+ "gbest_acc": 76.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.745193,
+ "gbest_acc": 76.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.7396,
+ "gbest_acc": 76.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.737082,
+ "gbest_acc": 76.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735965,
+ "gbest_acc": 77.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735053,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.731208,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.722121,
+ "gbest_acc": 78.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721947,
+ "gbest_acc": 77.4,
+ "val_loss": 0.777721,
+ "val_acc": 75.39
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721947,
+ "gbest_acc": 77.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.72003,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.716484,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.716484,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.715658,
+ "gbest_acc": 77.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.711825,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.708458,
+ "gbest_acc": 76.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706896,
+ "gbest_acc": 76.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.702222,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.691487,
+ "gbest_acc": 78.1,
+ "val_loss": 0.750659,
+ "val_acc": 76.08
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.691487,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.691487,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.690098,
+ "gbest_acc": 77.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688164,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688164,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.687971,
+ "gbest_acc": 77.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.68657,
+ "gbest_acc": 78.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.682741,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.682063,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.676684,
+ "gbest_acc": 78.6,
+ "val_loss": 0.756459,
+ "val_acc": 76.01
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.67594,
+ "gbest_acc": 77.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.672607,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.672607,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.671234,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.671234,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.671234,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.668974,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.656608,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.656608,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.654319,
+ "gbest_acc": 79.3,
+ "val_loss": 0.729946,
+ "val_acc": 76.7
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.651744,
+ "gbest_acc": 79.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.651744,
+ "gbest_acc": 79.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.651744,
+ "gbest_acc": 79.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.649753,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.645543,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.645543,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.645543,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.644104,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.643715,
+ "gbest_acc": 79.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.643715,
+ "gbest_acc": 79.6,
+ "val_loss": 0.71605,
+ "val_acc": 77.38
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.641782,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.640262,
+ "gbest_acc": 79.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.640262,
+ "gbest_acc": 79.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.640199,
+ "gbest_acc": 79.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.637268,
+ "gbest_acc": 80.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.63725,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.63725,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.63725,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.634589,
+ "gbest_acc": 79.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.633662,
+ "gbest_acc": 79.95,
+ "val_loss": 0.704695,
+ "val_acc": 77.65
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.632403,
+ "gbest_acc": 80.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.632403,
+ "gbest_acc": 80.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.631775,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.631775,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.629914,
+ "gbest_acc": 79.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.629536,
+ "gbest_acc": 79.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.629131,
+ "gbest_acc": 80.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.627174,
+ "gbest_acc": 79.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.625122,
+ "gbest_acc": 80.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.625122,
+ "gbest_acc": 80.15,
+ "val_loss": 0.697909,
+ "val_acc": 77.99
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.622897,
+ "gbest_acc": 80.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.621478,
+ "gbest_acc": 80.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.621478,
+ "gbest_acc": 80.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.62054,
+ "gbest_acc": 79.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.619069,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.619069,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.619069,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.619069,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.619069,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.617355,
+ "gbest_acc": 80.4,
+ "val_loss": 0.683026,
+ "val_acc": 78.47
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.614033,
+ "gbest_acc": 80.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.613715,
+ "gbest_acc": 80.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.610619,
+ "gbest_acc": 80.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.607618,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.607618,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.607618,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.607618,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.607618,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.605539,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602547,
+ "gbest_acc": 80.55,
+ "val_loss": 0.679565,
+ "val_acc": 78.83
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602547,
+ "gbest_acc": 80.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602547,
+ "gbest_acc": 80.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602219,
+ "gbest_acc": 80.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602219,
+ "gbest_acc": 80.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.600204,
+ "gbest_acc": 81.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.598711,
+ "gbest_acc": 80.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.596064,
+ "gbest_acc": 80.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.593586,
+ "gbest_acc": 81.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.593129,
+ "gbest_acc": 81.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.589757,
+ "gbest_acc": 81.35,
+ "val_loss": 0.664876,
+ "val_acc": 79.33
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.589757,
+ "gbest_acc": 81.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.589757,
+ "gbest_acc": 81.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.585914,
+ "gbest_acc": 81.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.583404,
+ "gbest_acc": 81.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.578445,
+ "gbest_acc": 81.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.578445,
+ "gbest_acc": 81.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.577449,
+ "gbest_acc": 81.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.571326,
+ "gbest_acc": 81.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.570525,
+ "gbest_acc": 81.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.570525,
+ "gbest_acc": 81.85,
+ "val_loss": 0.648621,
+ "val_acc": 79.67
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.568236,
+ "gbest_acc": 82.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.563785,
+ "gbest_acc": 82.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.563785,
+ "gbest_acc": 82.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.560781,
+ "gbest_acc": 82.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.557007,
+ "gbest_acc": 82.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.553164,
+ "gbest_acc": 82.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.552973,
+ "gbest_acc": 83.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.552973,
+ "gbest_acc": 83.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.552757,
+ "gbest_acc": 82.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.54992,
+ "gbest_acc": 83.1,
+ "val_loss": 0.629392,
+ "val_acc": 80.25
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.549891,
+ "gbest_acc": 82.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.547268,
+ "gbest_acc": 83.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.547268,
+ "gbest_acc": 83.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.547268,
+ "gbest_acc": 83.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.546574,
+ "gbest_acc": 83.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.546045,
+ "gbest_acc": 83.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.544973,
+ "gbest_acc": 83.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.543255,
+ "gbest_acc": 83.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.542889,
+ "gbest_acc": 83.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.540533,
+ "gbest_acc": 83.6,
+ "val_loss": 0.625339,
+ "val_acc": 80.69
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.539209,
+ "gbest_acc": 83.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.538794,
+ "gbest_acc": 83.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.538411,
+ "gbest_acc": 83.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.538411,
+ "gbest_acc": 83.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.538411,
+ "gbest_acc": 83.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.537941,
+ "gbest_acc": 84.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.536921,
+ "gbest_acc": 84.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.536921,
+ "gbest_acc": 84.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.53483,
+ "gbest_acc": 84.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.53483,
+ "gbest_acc": 84.05,
+ "val_loss": 0.622437,
+ "val_acc": 80.62
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.534221,
+ "gbest_acc": 83.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.534221,
+ "gbest_acc": 83.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.534221,
+ "gbest_acc": 83.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.534221,
+ "gbest_acc": 83.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.534049,
+ "gbest_acc": 84.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.531737,
+ "gbest_acc": 84.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.53141,
+ "gbest_acc": 84.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.529791,
+ "gbest_acc": 84.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.526769,
+ "gbest_acc": 84.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.526289,
+ "gbest_acc": 84.45,
+ "val_loss": 0.614736,
+ "val_acc": 80.92
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.523946,
+ "gbest_acc": 84.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.523923,
+ "gbest_acc": 84.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.520736,
+ "gbest_acc": 84.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.519374,
+ "gbest_acc": 84.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.518565,
+ "gbest_acc": 84.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.517725,
+ "gbest_acc": 85.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.51526,
+ "gbest_acc": 84.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.513082,
+ "gbest_acc": 84.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.513082,
+ "gbest_acc": 84.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.513082,
+ "gbest_acc": 84.4,
+ "val_loss": 0.598993,
+ "val_acc": 81.46
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.513069,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.511372,
+ "gbest_acc": 85.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.511372,
+ "gbest_acc": 85.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.511283,
+ "gbest_acc": 85.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.509333,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.505832,
+ "gbest_acc": 85.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.505832,
+ "gbest_acc": 85.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.505385,
+ "gbest_acc": 85.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.505166,
+ "gbest_acc": 85.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.505166,
+ "gbest_acc": 85.25,
+ "val_loss": 0.592996,
+ "val_acc": 81.86
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.504309,
+ "gbest_acc": 85.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.503304,
+ "gbest_acc": 85.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.503304,
+ "gbest_acc": 85.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.503092,
+ "gbest_acc": 85.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.502018,
+ "gbest_acc": 84.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.499907,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.499907,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.499907,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.499907,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.499481,
+ "gbest_acc": 85.1,
+ "val_loss": 0.585645,
+ "val_acc": 81.91
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.497878,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.496681,
+ "gbest_acc": 85.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.49653,
+ "gbest_acc": 85.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.495963,
+ "gbest_acc": 84.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.494219,
+ "gbest_acc": 85.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.49232,
+ "gbest_acc": 85.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.488723,
+ "gbest_acc": 85.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.488723,
+ "gbest_acc": 85.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.487032,
+ "gbest_acc": 85.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.485459,
+ "gbest_acc": 85.6,
+ "val_loss": 0.56757,
+ "val_acc": 82.72
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.485304,
+ "gbest_acc": 85.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.485304,
+ "gbest_acc": 85.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.48487,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.484722,
+ "gbest_acc": 85.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.483125,
+ "gbest_acc": 85.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.478797,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.478309,
+ "gbest_acc": 85.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.478182,
+ "gbest_acc": 85.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.475734,
+ "gbest_acc": 85.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.475734,
+ "gbest_acc": 85.65,
+ "val_loss": 0.56133,
+ "val_acc": 82.91
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.474674,
+ "gbest_acc": 85.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.474674,
+ "gbest_acc": 85.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.473268,
+ "gbest_acc": 85.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.472336,
+ "gbest_acc": 86.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.469716,
+ "gbest_acc": 85.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.469644,
+ "gbest_acc": 86.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.469522,
+ "gbest_acc": 86.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.468444,
+ "gbest_acc": 86.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.468444,
+ "gbest_acc": 86.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46796,
+ "gbest_acc": 86.05,
+ "val_loss": 0.556472,
+ "val_acc": 82.91
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.465867,
+ "gbest_acc": 86.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.464468,
+ "gbest_acc": 86.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.463928,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.463348,
+ "gbest_acc": 86.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.462208,
+ "gbest_acc": 86.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.462006,
+ "gbest_acc": 86.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.460101,
+ "gbest_acc": 86.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.458848,
+ "gbest_acc": 86.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.457235,
+ "gbest_acc": 86.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.456548,
+ "gbest_acc": 86.75,
+ "val_loss": 0.546986,
+ "val_acc": 83.31
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.453984,
+ "gbest_acc": 86.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.453984,
+ "gbest_acc": 86.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.453381,
+ "gbest_acc": 86.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.453381,
+ "gbest_acc": 86.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.451169,
+ "gbest_acc": 86.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.451149,
+ "gbest_acc": 86.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.450155,
+ "gbest_acc": 87.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45006,
+ "gbest_acc": 87.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.449159,
+ "gbest_acc": 87.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.447856,
+ "gbest_acc": 86.8,
+ "val_loss": 0.535878,
+ "val_acc": 83.44
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.446597,
+ "gbest_acc": 86.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.446393,
+ "gbest_acc": 86.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.443804,
+ "gbest_acc": 86.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.443348,
+ "gbest_acc": 86.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.440845,
+ "gbest_acc": 86.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.439439,
+ "gbest_acc": 86.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.437922,
+ "gbest_acc": 86.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.435815,
+ "gbest_acc": 86.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.435671,
+ "gbest_acc": 86.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.435671,
+ "gbest_acc": 86.75,
+ "val_loss": 0.532956,
+ "val_acc": 83.79
+ }
+ ],
+ "seed": 102,
+ "geometry_config": {
+ "config_id": "G5",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test sufficient bound expansion"
+ }
+ },
+ {
+ "config_id": "G5",
+ "gbest_loss": 0.442053,
+ "gbest_acc": 85.7,
+ "gbest_val_loss": 0.521308,
+ "gbest_val_acc": 83.61,
+ "val_selected_particle_idx": 35,
+ "val_selected_loss": 0.519183,
+ "val_selected_acc": 83.7,
+ "val_metrics": {
+ "accuracy": 83.7,
+ "nll": 0.519183,
+ "brier": 0.238524,
+ "ece": 0.01629,
+ "margin": 0.722691
+ },
+ "wall_time_sec": 32.7942,
+ "optimization_wall_time_sec": 32.3688,
+ "validation_wall_time_sec": 0.4254,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 520,
+ "final_moment_steps": [
+ 37,
+ 54,
+ 23,
+ 120,
+ 78,
+ 5,
+ 133,
+ 90,
+ 97,
+ 5,
+ 31,
+ 207,
+ 48,
+ 70,
+ 25,
+ 1,
+ 52,
+ 23,
+ 37,
+ 13,
+ 1,
+ 28,
+ 7,
+ 70,
+ 24,
+ 65,
+ 20,
+ 45,
+ 75,
+ 99,
+ 1,
+ 111,
+ 40,
+ 19,
+ 75,
+ 38,
+ 10,
+ 41,
+ 84,
+ 50,
+ 4,
+ 12,
+ 54,
+ 13,
+ 117,
+ 22,
+ 12,
+ 55,
+ 29,
+ 58,
+ 40,
+ 57,
+ 49,
+ 43,
+ 166,
+ 108,
+ 54,
+ 34,
+ 44,
+ 27
+ ],
+ "pbest_update_counts": 9827,
+ "boundary_hits": 259379,
+ "boundary_occupancy": 0.001131,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.1292,
+ "position_radius": 8.976848,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.306736,
+ "gbest_acc": 7.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.297185,
+ "gbest_acc": 8.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.275908,
+ "gbest_acc": 12.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.261282,
+ "gbest_acc": 19.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.238174,
+ "gbest_acc": 18.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.223287,
+ "gbest_acc": 19.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.191756,
+ "gbest_acc": 18.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.142016,
+ "gbest_acc": 23.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.094206,
+ "gbest_acc": 27.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.063807,
+ "gbest_acc": 25.7,
+ "val_loss": 2.070425,
+ "val_acc": 25.22
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.05024,
+ "gbest_acc": 28.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.005893,
+ "gbest_acc": 29.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.970084,
+ "gbest_acc": 30.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.970084,
+ "gbest_acc": 30.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.970084,
+ "gbest_acc": 30.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.934466,
+ "gbest_acc": 30.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.934466,
+ "gbest_acc": 30.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.934466,
+ "gbest_acc": 30.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.930831,
+ "gbest_acc": 30.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.900772,
+ "gbest_acc": 33.0,
+ "val_loss": 1.919232,
+ "val_acc": 32.7
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.876959,
+ "gbest_acc": 33.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.876959,
+ "gbest_acc": 33.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.87011,
+ "gbest_acc": 32.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.845989,
+ "gbest_acc": 34.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.831086,
+ "gbest_acc": 32.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.80325,
+ "gbest_acc": 38.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.802307,
+ "gbest_acc": 36.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.778686,
+ "gbest_acc": 36.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.778686,
+ "gbest_acc": 36.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.778686,
+ "gbest_acc": 36.15,
+ "val_loss": 1.795839,
+ "val_acc": 36.88
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.778686,
+ "gbest_acc": 36.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.767178,
+ "gbest_acc": 36.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.757479,
+ "gbest_acc": 37.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.750223,
+ "gbest_acc": 37.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.750223,
+ "gbest_acc": 37.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.727912,
+ "gbest_acc": 38.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.704062,
+ "gbest_acc": 38.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.658214,
+ "gbest_acc": 39.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.65289,
+ "gbest_acc": 41.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.649048,
+ "gbest_acc": 43.35,
+ "val_loss": 1.675824,
+ "val_acc": 42.85
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.645542,
+ "gbest_acc": 45.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.597496,
+ "gbest_acc": 43.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.578852,
+ "gbest_acc": 45.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.578852,
+ "gbest_acc": 45.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.578852,
+ "gbest_acc": 45.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.578852,
+ "gbest_acc": 45.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.565042,
+ "gbest_acc": 46.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.560975,
+ "gbest_acc": 48.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.543624,
+ "gbest_acc": 47.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.540555,
+ "gbest_acc": 48.8,
+ "val_loss": 1.570713,
+ "val_acc": 48.0
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.524486,
+ "gbest_acc": 47.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.520601,
+ "gbest_acc": 46.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.520601,
+ "gbest_acc": 46.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.520601,
+ "gbest_acc": 46.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.514753,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.514753,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.509157,
+ "gbest_acc": 48.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.509157,
+ "gbest_acc": 48.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.509157,
+ "gbest_acc": 48.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.509157,
+ "gbest_acc": 48.75,
+ "val_loss": 1.551392,
+ "val_acc": 47.39
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460085,
+ "gbest_acc": 50.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460085,
+ "gbest_acc": 50.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460085,
+ "gbest_acc": 50.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460085,
+ "gbest_acc": 50.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460085,
+ "gbest_acc": 50.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.459682,
+ "gbest_acc": 50.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.424368,
+ "gbest_acc": 52.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.421782,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.421782,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.421782,
+ "gbest_acc": 51.9,
+ "val_loss": 1.46463,
+ "val_acc": 51.74
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.41545,
+ "gbest_acc": 52.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.411804,
+ "gbest_acc": 52.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.411804,
+ "gbest_acc": 52.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.394839,
+ "gbest_acc": 53.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.394839,
+ "gbest_acc": 53.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.39342,
+ "gbest_acc": 52.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.379512,
+ "gbest_acc": 54.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.358883,
+ "gbest_acc": 54.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.358883,
+ "gbest_acc": 54.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.358883,
+ "gbest_acc": 54.65,
+ "val_loss": 1.394204,
+ "val_acc": 53.44
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.355258,
+ "gbest_acc": 55.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.349152,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.342287,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.342287,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.342287,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.336709,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.336709,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331797,
+ "gbest_acc": 55.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331797,
+ "gbest_acc": 55.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.330911,
+ "gbest_acc": 55.4,
+ "val_loss": 1.373266,
+ "val_acc": 54.95
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.330911,
+ "gbest_acc": 55.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.326333,
+ "gbest_acc": 56.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.326333,
+ "gbest_acc": 56.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.324818,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.318744,
+ "gbest_acc": 56.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.31621,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.314044,
+ "gbest_acc": 56.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.309402,
+ "gbest_acc": 55.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.296692,
+ "gbest_acc": 57.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.281567,
+ "gbest_acc": 57.75,
+ "val_loss": 1.327476,
+ "val_acc": 55.74
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.281567,
+ "gbest_acc": 57.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.281567,
+ "gbest_acc": 57.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279069,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279069,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.266293,
+ "gbest_acc": 57.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26623,
+ "gbest_acc": 57.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.257732,
+ "gbest_acc": 57.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.2535,
+ "gbest_acc": 59.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.2535,
+ "gbest_acc": 59.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.248533,
+ "gbest_acc": 59.4,
+ "val_loss": 1.302965,
+ "val_acc": 56.8
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.243469,
+ "gbest_acc": 57.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.242401,
+ "gbest_acc": 57.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.2353,
+ "gbest_acc": 58.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.218341,
+ "gbest_acc": 60.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.218341,
+ "gbest_acc": 60.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.218341,
+ "gbest_acc": 60.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.217208,
+ "gbest_acc": 59.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.217208,
+ "gbest_acc": 59.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.213103,
+ "gbest_acc": 58.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199533,
+ "gbest_acc": 60.15,
+ "val_loss": 1.254425,
+ "val_acc": 58.63
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199533,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199413,
+ "gbest_acc": 59.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.195405,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.182786,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.182786,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.179841,
+ "gbest_acc": 60.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.17483,
+ "gbest_acc": 61.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.1661,
+ "gbest_acc": 61.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.162926,
+ "gbest_acc": 61.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.162926,
+ "gbest_acc": 61.6,
+ "val_loss": 1.218548,
+ "val_acc": 60.15
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.157818,
+ "gbest_acc": 62.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.151371,
+ "gbest_acc": 62.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.150804,
+ "gbest_acc": 63.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.14374,
+ "gbest_acc": 62.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.137372,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.121171,
+ "gbest_acc": 63.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.121171,
+ "gbest_acc": 63.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.114312,
+ "gbest_acc": 64.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.107682,
+ "gbest_acc": 63.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.100526,
+ "gbest_acc": 64.7,
+ "val_loss": 1.141972,
+ "val_acc": 62.72
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.08024,
+ "gbest_acc": 64.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.074158,
+ "gbest_acc": 64.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.071947,
+ "gbest_acc": 64.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.059806,
+ "gbest_acc": 64.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.05422,
+ "gbest_acc": 65.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.05422,
+ "gbest_acc": 65.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.05422,
+ "gbest_acc": 65.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.046523,
+ "gbest_acc": 66.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.037713,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.037713,
+ "gbest_acc": 66.85,
+ "val_loss": 1.087123,
+ "val_acc": 65.15
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.037713,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.035951,
+ "gbest_acc": 66.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.029403,
+ "gbest_acc": 67.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.025879,
+ "gbest_acc": 67.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.020176,
+ "gbest_acc": 67.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.018134,
+ "gbest_acc": 67.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.015306,
+ "gbest_acc": 67.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.012,
+ "gbest_acc": 66.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.00923,
+ "gbest_acc": 66.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.008767,
+ "gbest_acc": 67.3,
+ "val_loss": 1.054763,
+ "val_acc": 65.46
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.003297,
+ "gbest_acc": 67.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.998366,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993813,
+ "gbest_acc": 67.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990881,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990881,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.990881,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.985305,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.979103,
+ "gbest_acc": 67.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.977941,
+ "gbest_acc": 67.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.973284,
+ "gbest_acc": 67.65,
+ "val_loss": 1.020858,
+ "val_acc": 66.85
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.960294,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.948434,
+ "gbest_acc": 68.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.943418,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.937466,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.937466,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.935301,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.928168,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.923367,
+ "gbest_acc": 69.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92013,
+ "gbest_acc": 69.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.910884,
+ "gbest_acc": 70.05,
+ "val_loss": 0.958899,
+ "val_acc": 68.54
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.908031,
+ "gbest_acc": 69.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.901616,
+ "gbest_acc": 69.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.89116,
+ "gbest_acc": 71.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.888514,
+ "gbest_acc": 71.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.887281,
+ "gbest_acc": 71.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87708,
+ "gbest_acc": 71.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87708,
+ "gbest_acc": 71.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871466,
+ "gbest_acc": 71.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871207,
+ "gbest_acc": 71.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.871207,
+ "gbest_acc": 71.3,
+ "val_loss": 0.918171,
+ "val_acc": 70.14
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.868761,
+ "gbest_acc": 71.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.865656,
+ "gbest_acc": 71.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.865656,
+ "gbest_acc": 71.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.865656,
+ "gbest_acc": 71.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858094,
+ "gbest_acc": 72.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858094,
+ "gbest_acc": 72.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858094,
+ "gbest_acc": 72.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.856944,
+ "gbest_acc": 71.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.850975,
+ "gbest_acc": 71.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849424,
+ "gbest_acc": 72.35,
+ "val_loss": 0.891239,
+ "val_acc": 71.14
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849424,
+ "gbest_acc": 72.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.84828,
+ "gbest_acc": 72.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.84828,
+ "gbest_acc": 72.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.84828,
+ "gbest_acc": 72.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.846003,
+ "gbest_acc": 72.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.844526,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.836183,
+ "gbest_acc": 72.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.83176,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.82558,
+ "gbest_acc": 73.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.82558,
+ "gbest_acc": 73.5,
+ "val_loss": 0.874743,
+ "val_acc": 71.38
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.819443,
+ "gbest_acc": 73.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.811219,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.81111,
+ "gbest_acc": 74.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809974,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.804929,
+ "gbest_acc": 74.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.801301,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.799451,
+ "gbest_acc": 74.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.79526,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.794777,
+ "gbest_acc": 75.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.789055,
+ "gbest_acc": 75.1,
+ "val_loss": 0.831572,
+ "val_acc": 73.12
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.786607,
+ "gbest_acc": 74.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.786296,
+ "gbest_acc": 75.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78364,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.779951,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.776929,
+ "gbest_acc": 75.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.776929,
+ "gbest_acc": 75.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.77263,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.770307,
+ "gbest_acc": 75.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.766831,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.766831,
+ "gbest_acc": 75.75,
+ "val_loss": 0.814645,
+ "val_acc": 74.17
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.765462,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.765462,
+ "gbest_acc": 75.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.764405,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758501,
+ "gbest_acc": 75.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.757141,
+ "gbest_acc": 77.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.755668,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.755668,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.751674,
+ "gbest_acc": 76.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.747013,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743434,
+ "gbest_acc": 77.8,
+ "val_loss": 0.789342,
+ "val_acc": 75.37
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743024,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.741907,
+ "gbest_acc": 76.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.737457,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.736886,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.736886,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735852,
+ "gbest_acc": 76.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.728796,
+ "gbest_acc": 76.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.728402,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.728402,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.728402,
+ "gbest_acc": 77.2,
+ "val_loss": 0.77999,
+ "val_acc": 75.41
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.728402,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.726773,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.722022,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.715028,
+ "gbest_acc": 77.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.715028,
+ "gbest_acc": 77.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.714914,
+ "gbest_acc": 77.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.713,
+ "gbest_acc": 77.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706887,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703322,
+ "gbest_acc": 78.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703322,
+ "gbest_acc": 78.3,
+ "val_loss": 0.754679,
+ "val_acc": 76.37
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.703104,
+ "gbest_acc": 78.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.702634,
+ "gbest_acc": 78.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.701571,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.690286,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.690286,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.687528,
+ "gbest_acc": 78.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.686657,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.680466,
+ "gbest_acc": 78.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.680466,
+ "gbest_acc": 78.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.680466,
+ "gbest_acc": 78.25,
+ "val_loss": 0.733534,
+ "val_acc": 77.41
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.676064,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.674546,
+ "gbest_acc": 78.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.674546,
+ "gbest_acc": 78.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.67199,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.668459,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.668459,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.665279,
+ "gbest_acc": 78.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.661767,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.661767,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.661767,
+ "gbest_acc": 79.3,
+ "val_loss": 0.712344,
+ "val_acc": 78.13
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.655168,
+ "gbest_acc": 79.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.655096,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.653603,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.653603,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.649705,
+ "gbest_acc": 79.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.649705,
+ "gbest_acc": 79.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.649705,
+ "gbest_acc": 79.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.649661,
+ "gbest_acc": 80.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.643849,
+ "gbest_acc": 79.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.643849,
+ "gbest_acc": 79.85,
+ "val_loss": 0.69507,
+ "val_acc": 78.63
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.641536,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.639686,
+ "gbest_acc": 79.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.635769,
+ "gbest_acc": 80.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.632509,
+ "gbest_acc": 80.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.630942,
+ "gbest_acc": 80.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.629515,
+ "gbest_acc": 80.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.626334,
+ "gbest_acc": 80.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.625286,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.621115,
+ "gbest_acc": 80.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.617955,
+ "gbest_acc": 80.75,
+ "val_loss": 0.674398,
+ "val_acc": 78.82
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.614585,
+ "gbest_acc": 81.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.608756,
+ "gbest_acc": 81.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602616,
+ "gbest_acc": 82.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602616,
+ "gbest_acc": 82.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.601657,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.600788,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.599243,
+ "gbest_acc": 82.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.596707,
+ "gbest_acc": 82.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.591084,
+ "gbest_acc": 82.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.590371,
+ "gbest_acc": 82.55,
+ "val_loss": 0.653407,
+ "val_acc": 79.82
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.590371,
+ "gbest_acc": 82.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.587929,
+ "gbest_acc": 81.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.587929,
+ "gbest_acc": 81.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.58599,
+ "gbest_acc": 81.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.58599,
+ "gbest_acc": 81.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.583473,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.581936,
+ "gbest_acc": 82.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.581819,
+ "gbest_acc": 82.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.580797,
+ "gbest_acc": 82.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.578253,
+ "gbest_acc": 82.65,
+ "val_loss": 0.636929,
+ "val_acc": 80.15
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.577889,
+ "gbest_acc": 82.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.576631,
+ "gbest_acc": 82.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.574548,
+ "gbest_acc": 82.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.572073,
+ "gbest_acc": 82.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.569359,
+ "gbest_acc": 82.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.565705,
+ "gbest_acc": 82.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.563951,
+ "gbest_acc": 83.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.562887,
+ "gbest_acc": 82.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.562203,
+ "gbest_acc": 83.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.561083,
+ "gbest_acc": 83.1,
+ "val_loss": 0.625473,
+ "val_acc": 80.41
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.559194,
+ "gbest_acc": 83.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.558144,
+ "gbest_acc": 83.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.556224,
+ "gbest_acc": 83.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.553584,
+ "gbest_acc": 83.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.55243,
+ "gbest_acc": 82.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.551704,
+ "gbest_acc": 83.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.551704,
+ "gbest_acc": 83.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.551704,
+ "gbest_acc": 83.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.551704,
+ "gbest_acc": 83.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.551704,
+ "gbest_acc": 83.0,
+ "val_loss": 0.615447,
+ "val_acc": 80.72
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.551704,
+ "gbest_acc": 83.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.550319,
+ "gbest_acc": 83.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.549663,
+ "gbest_acc": 82.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.547197,
+ "gbest_acc": 83.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.54464,
+ "gbest_acc": 83.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.543198,
+ "gbest_acc": 83.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.540544,
+ "gbest_acc": 83.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.54014,
+ "gbest_acc": 83.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.535296,
+ "gbest_acc": 83.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.533476,
+ "gbest_acc": 83.55,
+ "val_loss": 0.593913,
+ "val_acc": 81.5
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.532509,
+ "gbest_acc": 83.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.530881,
+ "gbest_acc": 83.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.52929,
+ "gbest_acc": 83.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.528764,
+ "gbest_acc": 84.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.527635,
+ "gbest_acc": 83.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.523777,
+ "gbest_acc": 84.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.522284,
+ "gbest_acc": 84.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.521033,
+ "gbest_acc": 83.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.515299,
+ "gbest_acc": 84.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.514652,
+ "gbest_acc": 84.05,
+ "val_loss": 0.578546,
+ "val_acc": 82.27
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.51364,
+ "gbest_acc": 84.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.511437,
+ "gbest_acc": 84.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.509611,
+ "gbest_acc": 84.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.509059,
+ "gbest_acc": 84.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.505414,
+ "gbest_acc": 84.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.505142,
+ "gbest_acc": 84.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.501224,
+ "gbest_acc": 84.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.501044,
+ "gbest_acc": 84.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.49983,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.49949,
+ "gbest_acc": 85.2,
+ "val_loss": 0.564309,
+ "val_acc": 82.61
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.49843,
+ "gbest_acc": 84.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.49768,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.497555,
+ "gbest_acc": 84.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.49649,
+ "gbest_acc": 84.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.493587,
+ "gbest_acc": 84.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.491822,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.491822,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.488116,
+ "gbest_acc": 84.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.486845,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.48496,
+ "gbest_acc": 85.1,
+ "val_loss": 0.547115,
+ "val_acc": 82.84
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.483142,
+ "gbest_acc": 85.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.483142,
+ "gbest_acc": 85.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.482848,
+ "gbest_acc": 84.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.482848,
+ "gbest_acc": 84.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.478236,
+ "gbest_acc": 85.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.478236,
+ "gbest_acc": 85.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.477109,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.473795,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.473005,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.473005,
+ "gbest_acc": 85.9,
+ "val_loss": 0.541918,
+ "val_acc": 83.09
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.472408,
+ "gbest_acc": 85.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.471128,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46943,
+ "gbest_acc": 86.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.468182,
+ "gbest_acc": 85.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.468182,
+ "gbest_acc": 85.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.468013,
+ "gbest_acc": 85.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.466745,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.465288,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.464297,
+ "gbest_acc": 85.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.463146,
+ "gbest_acc": 85.85,
+ "val_loss": 0.53566,
+ "val_acc": 83.33
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.462261,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.461616,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.460729,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.460542,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.458529,
+ "gbest_acc": 85.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45788,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.455815,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.455815,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.453573,
+ "gbest_acc": 86.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.451108,
+ "gbest_acc": 86.2,
+ "val_loss": 0.525727,
+ "val_acc": 83.79
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.450953,
+ "gbest_acc": 86.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.450772,
+ "gbest_acc": 86.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.449977,
+ "gbest_acc": 86.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.449015,
+ "gbest_acc": 86.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.447081,
+ "gbest_acc": 86.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.446481,
+ "gbest_acc": 86.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.44537,
+ "gbest_acc": 86.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.444306,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.443198,
+ "gbest_acc": 85.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.442053,
+ "gbest_acc": 85.7,
+ "val_loss": 0.521308,
+ "val_acc": 83.61
+ }
+ ],
+ "seed": 103,
+ "geometry_config": {
+ "config_id": "G5",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test sufficient bound expansion"
+ }
+ }
+ ],
+ "G6": [
+ {
+ "config_id": "G6",
+ "gbest_loss": 0.422646,
+ "gbest_acc": 86.75,
+ "gbest_val_loss": 0.498121,
+ "gbest_val_acc": 84.2,
+ "val_selected_particle_idx": 41,
+ "val_selected_loss": 0.498121,
+ "val_selected_acc": 84.2,
+ "val_metrics": {
+ "accuracy": 84.2,
+ "nll": 0.498121,
+ "brier": 0.230765,
+ "ece": 0.023868,
+ "margin": 0.714704
+ },
+ "wall_time_sec": 33.2029,
+ "optimization_wall_time_sec": 32.7858,
+ "validation_wall_time_sec": 0.4171,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 467,
+ "final_moment_steps": [
+ 9,
+ 72,
+ 16,
+ 171,
+ 84,
+ 155,
+ 102,
+ 104,
+ 19,
+ 2,
+ 90,
+ 29,
+ 50,
+ 63,
+ 143,
+ 10,
+ 99,
+ 39,
+ 87,
+ 27,
+ 5,
+ 7,
+ 27,
+ 8,
+ 11,
+ 5,
+ 12,
+ 26,
+ 8,
+ 49,
+ 55,
+ 80,
+ 93,
+ 40,
+ 13,
+ 7,
+ 7,
+ 15,
+ 73,
+ 1,
+ 54,
+ 239,
+ 76,
+ 33,
+ 6,
+ 21,
+ 56,
+ 28,
+ 4,
+ 1,
+ 25,
+ 88,
+ 115,
+ 60,
+ 8,
+ 129,
+ 13,
+ 53,
+ 19,
+ 11
+ ],
+ "pbest_update_counts": 9734,
+ "boundary_hits": 313172,
+ "boundary_occupancy": 0.001366,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.184976,
+ "position_radius": 12.968482,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.325288,
+ "gbest_acc": 7.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.302071,
+ "gbest_acc": 10.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.288745,
+ "gbest_acc": 6.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.270416,
+ "gbest_acc": 9.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.251149,
+ "gbest_acc": 14.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.224668,
+ "gbest_acc": 17.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.164184,
+ "gbest_acc": 21.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.159015,
+ "gbest_acc": 20.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.121732,
+ "gbest_acc": 22.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.11508,
+ "gbest_acc": 22.25,
+ "val_loss": 2.10606,
+ "val_acc": 23.35
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.106247,
+ "gbest_acc": 21.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.106247,
+ "gbest_acc": 21.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.038369,
+ "gbest_acc": 24.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.038369,
+ "gbest_acc": 24.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.038369,
+ "gbest_acc": 24.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.038369,
+ "gbest_acc": 24.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.019926,
+ "gbest_acc": 23.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.966944,
+ "gbest_acc": 29.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.966944,
+ "gbest_acc": 29.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.966804,
+ "gbest_acc": 30.2,
+ "val_loss": 1.9614,
+ "val_acc": 31.11
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.941425,
+ "gbest_acc": 29.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.91478,
+ "gbest_acc": 31.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883577,
+ "gbest_acc": 34.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883577,
+ "gbest_acc": 34.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883577,
+ "gbest_acc": 34.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883577,
+ "gbest_acc": 34.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.860669,
+ "gbest_acc": 36.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.837765,
+ "gbest_acc": 36.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.837765,
+ "gbest_acc": 36.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.834462,
+ "gbest_acc": 36.8,
+ "val_loss": 1.824032,
+ "val_acc": 37.79
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.824751,
+ "gbest_acc": 37.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.79815,
+ "gbest_acc": 36.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.77698,
+ "gbest_acc": 38.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.77698,
+ "gbest_acc": 38.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.77698,
+ "gbest_acc": 38.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.737576,
+ "gbest_acc": 41.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.69875,
+ "gbest_acc": 41.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.69875,
+ "gbest_acc": 41.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.69875,
+ "gbest_acc": 41.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.660816,
+ "gbest_acc": 43.3,
+ "val_loss": 1.640026,
+ "val_acc": 44.31
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.660816,
+ "gbest_acc": 43.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.660816,
+ "gbest_acc": 43.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.659908,
+ "gbest_acc": 42.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.656381,
+ "gbest_acc": 43.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.640883,
+ "gbest_acc": 44.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.640883,
+ "gbest_acc": 44.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.622697,
+ "gbest_acc": 45.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.622697,
+ "gbest_acc": 45.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.610256,
+ "gbest_acc": 45.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.603877,
+ "gbest_acc": 46.3,
+ "val_loss": 1.575655,
+ "val_acc": 46.36
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.603877,
+ "gbest_acc": 46.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.603877,
+ "gbest_acc": 46.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.589292,
+ "gbest_acc": 45.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.57426,
+ "gbest_acc": 45.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.561933,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.561933,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.561933,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.56093,
+ "gbest_acc": 46.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.559979,
+ "gbest_acc": 46.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.547555,
+ "gbest_acc": 46.9,
+ "val_loss": 1.530129,
+ "val_acc": 47.08
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.547555,
+ "gbest_acc": 46.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.534715,
+ "gbest_acc": 47.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.511108,
+ "gbest_acc": 50.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.501531,
+ "gbest_acc": 50.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.501531,
+ "gbest_acc": 50.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.481139,
+ "gbest_acc": 50.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.481139,
+ "gbest_acc": 50.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.481139,
+ "gbest_acc": 50.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.469667,
+ "gbest_acc": 51.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.463591,
+ "gbest_acc": 51.05,
+ "val_loss": 1.450185,
+ "val_acc": 51.35
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.447661,
+ "gbest_acc": 51.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.443456,
+ "gbest_acc": 52.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.417341,
+ "gbest_acc": 51.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.404086,
+ "gbest_acc": 52.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.404086,
+ "gbest_acc": 52.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.404086,
+ "gbest_acc": 52.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.397283,
+ "gbest_acc": 52.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.396259,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.374056,
+ "gbest_acc": 53.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.360019,
+ "gbest_acc": 52.9,
+ "val_loss": 1.368318,
+ "val_acc": 52.98
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.343276,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.343276,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.326914,
+ "gbest_acc": 54.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.319507,
+ "gbest_acc": 54.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.297533,
+ "gbest_acc": 55.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.29082,
+ "gbest_acc": 55.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282334,
+ "gbest_acc": 55.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.258383,
+ "gbest_acc": 56.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.24642,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.242492,
+ "gbest_acc": 56.1,
+ "val_loss": 1.251733,
+ "val_acc": 56.93
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.211298,
+ "gbest_acc": 58.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.211298,
+ "gbest_acc": 58.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.201677,
+ "gbest_acc": 58.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.201677,
+ "gbest_acc": 58.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199275,
+ "gbest_acc": 58.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199275,
+ "gbest_acc": 58.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199275,
+ "gbest_acc": 58.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199275,
+ "gbest_acc": 58.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.195969,
+ "gbest_acc": 60.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.186559,
+ "gbest_acc": 59.3,
+ "val_loss": 1.189966,
+ "val_acc": 60.28
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177155,
+ "gbest_acc": 59.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177155,
+ "gbest_acc": 59.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.163084,
+ "gbest_acc": 61.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.163084,
+ "gbest_acc": 61.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.152427,
+ "gbest_acc": 61.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.152427,
+ "gbest_acc": 61.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.145308,
+ "gbest_acc": 62.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.145308,
+ "gbest_acc": 62.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.140341,
+ "gbest_acc": 61.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.131055,
+ "gbest_acc": 62.5,
+ "val_loss": 1.138847,
+ "val_acc": 63.32
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.119077,
+ "gbest_acc": 64.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.117963,
+ "gbest_acc": 64.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.116485,
+ "gbest_acc": 63.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.110609,
+ "gbest_acc": 63.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.100844,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.094726,
+ "gbest_acc": 64.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.094726,
+ "gbest_acc": 64.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.093367,
+ "gbest_acc": 64.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.093367,
+ "gbest_acc": 64.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.08922,
+ "gbest_acc": 64.0,
+ "val_loss": 1.096235,
+ "val_acc": 64.26
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.081561,
+ "gbest_acc": 64.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.081561,
+ "gbest_acc": 64.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.072612,
+ "gbest_acc": 65.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.059915,
+ "gbest_acc": 65.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.053287,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.04576,
+ "gbest_acc": 65.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.037303,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.037303,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.028491,
+ "gbest_acc": 66.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.021647,
+ "gbest_acc": 66.6,
+ "val_loss": 1.037331,
+ "val_acc": 65.51
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.012943,
+ "gbest_acc": 66.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.012089,
+ "gbest_acc": 65.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.000414,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.999847,
+ "gbest_acc": 67.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993308,
+ "gbest_acc": 66.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.991361,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.991361,
+ "gbest_acc": 66.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.983344,
+ "gbest_acc": 68.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.976153,
+ "gbest_acc": 67.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.976153,
+ "gbest_acc": 67.8,
+ "val_loss": 0.985008,
+ "val_acc": 67.83
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.96945,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.966623,
+ "gbest_acc": 67.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.963894,
+ "gbest_acc": 67.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.96231,
+ "gbest_acc": 68.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.957384,
+ "gbest_acc": 68.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.956978,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.948183,
+ "gbest_acc": 68.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.946965,
+ "gbest_acc": 68.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.944815,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.940587,
+ "gbest_acc": 69.65,
+ "val_loss": 0.95434,
+ "val_acc": 68.84
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.937079,
+ "gbest_acc": 69.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.926923,
+ "gbest_acc": 69.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.918496,
+ "gbest_acc": 70.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.917579,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.917579,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.917579,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.917579,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.915622,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.915622,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.912761,
+ "gbest_acc": 69.65,
+ "val_loss": 0.924603,
+ "val_acc": 69.78
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.910818,
+ "gbest_acc": 69.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.905642,
+ "gbest_acc": 70.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.894908,
+ "gbest_acc": 69.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.887837,
+ "gbest_acc": 70.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.887829,
+ "gbest_acc": 70.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.876567,
+ "gbest_acc": 70.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875688,
+ "gbest_acc": 71.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875688,
+ "gbest_acc": 71.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875688,
+ "gbest_acc": 71.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.875688,
+ "gbest_acc": 71.55,
+ "val_loss": 0.89156,
+ "val_acc": 71.09
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.874923,
+ "gbest_acc": 71.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.868525,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.860586,
+ "gbest_acc": 71.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.860586,
+ "gbest_acc": 71.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.860586,
+ "gbest_acc": 71.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.859831,
+ "gbest_acc": 71.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858006,
+ "gbest_acc": 71.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.856833,
+ "gbest_acc": 71.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.850249,
+ "gbest_acc": 72.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.850249,
+ "gbest_acc": 72.25,
+ "val_loss": 0.868414,
+ "val_acc": 71.84
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.846892,
+ "gbest_acc": 72.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840734,
+ "gbest_acc": 72.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.834274,
+ "gbest_acc": 72.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.833712,
+ "gbest_acc": 72.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.826925,
+ "gbest_acc": 72.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.826798,
+ "gbest_acc": 72.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.820902,
+ "gbest_acc": 72.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.818615,
+ "gbest_acc": 72.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.815028,
+ "gbest_acc": 73.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809654,
+ "gbest_acc": 73.05,
+ "val_loss": 0.827736,
+ "val_acc": 72.87
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.806907,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.806907,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.805869,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.80526,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.800494,
+ "gbest_acc": 73.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.796721,
+ "gbest_acc": 73.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.796349,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.789376,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.789376,
+ "gbest_acc": 73.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.789376,
+ "gbest_acc": 73.7,
+ "val_loss": 0.811788,
+ "val_acc": 72.95
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.788132,
+ "gbest_acc": 73.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.784951,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.783866,
+ "gbest_acc": 74.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.779512,
+ "gbest_acc": 74.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.777102,
+ "gbest_acc": 74.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.77492,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.774554,
+ "gbest_acc": 74.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.770049,
+ "gbest_acc": 74.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.76711,
+ "gbest_acc": 74.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.76684,
+ "gbest_acc": 75.05,
+ "val_loss": 0.794618,
+ "val_acc": 73.86
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.759418,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.755131,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.755131,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.755131,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.75459,
+ "gbest_acc": 74.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.75459,
+ "gbest_acc": 74.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.752403,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.751432,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.7479,
+ "gbest_acc": 76.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.745427,
+ "gbest_acc": 75.3,
+ "val_loss": 0.775677,
+ "val_acc": 74.2
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743449,
+ "gbest_acc": 75.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.743376,
+ "gbest_acc": 75.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.739578,
+ "gbest_acc": 75.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.736627,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.736627,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.736527,
+ "gbest_acc": 76.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.734686,
+ "gbest_acc": 76.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.732372,
+ "gbest_acc": 76.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.727993,
+ "gbest_acc": 77.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.726815,
+ "gbest_acc": 76.8,
+ "val_loss": 0.754594,
+ "val_acc": 75.34
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721197,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.721197,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.720229,
+ "gbest_acc": 77.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.719991,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.717911,
+ "gbest_acc": 77.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.712392,
+ "gbest_acc": 77.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.711427,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.708695,
+ "gbest_acc": 77.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.704916,
+ "gbest_acc": 77.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.704562,
+ "gbest_acc": 78.2,
+ "val_loss": 0.737616,
+ "val_acc": 75.91
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696734,
+ "gbest_acc": 77.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.696734,
+ "gbest_acc": 77.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.69428,
+ "gbest_acc": 78.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.691193,
+ "gbest_acc": 78.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.690999,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.687518,
+ "gbest_acc": 78.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.686303,
+ "gbest_acc": 78.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.686299,
+ "gbest_acc": 77.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.681493,
+ "gbest_acc": 78.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.677533,
+ "gbest_acc": 78.4,
+ "val_loss": 0.716108,
+ "val_acc": 76.64
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.676364,
+ "gbest_acc": 78.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.676364,
+ "gbest_acc": 78.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.674258,
+ "gbest_acc": 78.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.673639,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.673639,
+ "gbest_acc": 79.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.668731,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.668731,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.668731,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.668731,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.668731,
+ "gbest_acc": 79.0,
+ "val_loss": 0.70903,
+ "val_acc": 77.27
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.663879,
+ "gbest_acc": 78.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.663443,
+ "gbest_acc": 79.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.662462,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.660993,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.656626,
+ "gbest_acc": 79.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.655456,
+ "gbest_acc": 79.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.654003,
+ "gbest_acc": 79.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.653636,
+ "gbest_acc": 79.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.651132,
+ "gbest_acc": 78.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.650102,
+ "gbest_acc": 79.65,
+ "val_loss": 0.695312,
+ "val_acc": 77.37
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.64697,
+ "gbest_acc": 79.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.64377,
+ "gbest_acc": 80.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.642924,
+ "gbest_acc": 80.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.641412,
+ "gbest_acc": 80.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.635101,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.635101,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.635101,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.6341,
+ "gbest_acc": 80.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.629275,
+ "gbest_acc": 81.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.625885,
+ "gbest_acc": 80.55,
+ "val_loss": 0.675231,
+ "val_acc": 78.06
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.623786,
+ "gbest_acc": 80.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.622803,
+ "gbest_acc": 81.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.621965,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.617272,
+ "gbest_acc": 80.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.611598,
+ "gbest_acc": 81.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.610883,
+ "gbest_acc": 81.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.609396,
+ "gbest_acc": 81.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.609396,
+ "gbest_acc": 81.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.605327,
+ "gbest_acc": 81.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602194,
+ "gbest_acc": 81.4,
+ "val_loss": 0.658726,
+ "val_acc": 78.35
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602194,
+ "gbest_acc": 81.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602194,
+ "gbest_acc": 81.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602163,
+ "gbest_acc": 81.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.597134,
+ "gbest_acc": 82.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.597134,
+ "gbest_acc": 82.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.595101,
+ "gbest_acc": 81.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.59273,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.590998,
+ "gbest_acc": 81.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.590998,
+ "gbest_acc": 81.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.589006,
+ "gbest_acc": 82.15,
+ "val_loss": 0.644411,
+ "val_acc": 79.24
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.589006,
+ "gbest_acc": 82.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.589006,
+ "gbest_acc": 82.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.586809,
+ "gbest_acc": 81.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.583696,
+ "gbest_acc": 82.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.583159,
+ "gbest_acc": 82.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.58249,
+ "gbest_acc": 82.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.581256,
+ "gbest_acc": 82.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.581256,
+ "gbest_acc": 82.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.581256,
+ "gbest_acc": 82.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.580566,
+ "gbest_acc": 82.35,
+ "val_loss": 0.630781,
+ "val_acc": 79.88
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.580566,
+ "gbest_acc": 82.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.580306,
+ "gbest_acc": 82.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.577611,
+ "gbest_acc": 82.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.577566,
+ "gbest_acc": 82.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.577138,
+ "gbest_acc": 82.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.576081,
+ "gbest_acc": 82.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.573095,
+ "gbest_acc": 82.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.573095,
+ "gbest_acc": 82.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.573095,
+ "gbest_acc": 82.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.573095,
+ "gbest_acc": 82.25,
+ "val_loss": 0.623577,
+ "val_acc": 79.85
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.571111,
+ "gbest_acc": 82.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.569493,
+ "gbest_acc": 82.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.567935,
+ "gbest_acc": 82.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.566849,
+ "gbest_acc": 83.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.566209,
+ "gbest_acc": 82.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.563062,
+ "gbest_acc": 82.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.560977,
+ "gbest_acc": 83.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.558772,
+ "gbest_acc": 83.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.55875,
+ "gbest_acc": 82.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.557307,
+ "gbest_acc": 83.65,
+ "val_loss": 0.609808,
+ "val_acc": 80.14
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.555819,
+ "gbest_acc": 83.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.553574,
+ "gbest_acc": 83.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.552462,
+ "gbest_acc": 83.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.551195,
+ "gbest_acc": 83.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.549497,
+ "gbest_acc": 83.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.547591,
+ "gbest_acc": 83.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.546658,
+ "gbest_acc": 83.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.543749,
+ "gbest_acc": 84.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.542084,
+ "gbest_acc": 83.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.541091,
+ "gbest_acc": 84.05,
+ "val_loss": 0.592735,
+ "val_acc": 81.26
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.540557,
+ "gbest_acc": 83.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.538848,
+ "gbest_acc": 83.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.538096,
+ "gbest_acc": 84.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.535925,
+ "gbest_acc": 83.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.535925,
+ "gbest_acc": 83.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.535297,
+ "gbest_acc": 84.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.531614,
+ "gbest_acc": 83.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.530202,
+ "gbest_acc": 84.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.528425,
+ "gbest_acc": 84.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.527373,
+ "gbest_acc": 84.0,
+ "val_loss": 0.581933,
+ "val_acc": 81.43
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.524346,
+ "gbest_acc": 84.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.522365,
+ "gbest_acc": 84.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.517776,
+ "gbest_acc": 84.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.517528,
+ "gbest_acc": 84.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.515433,
+ "gbest_acc": 84.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.513631,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.510247,
+ "gbest_acc": 84.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.508977,
+ "gbest_acc": 84.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.507853,
+ "gbest_acc": 84.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.506345,
+ "gbest_acc": 84.5,
+ "val_loss": 0.560327,
+ "val_acc": 81.92
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.504395,
+ "gbest_acc": 84.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.501559,
+ "gbest_acc": 84.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.501346,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.50029,
+ "gbest_acc": 84.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.497455,
+ "gbest_acc": 84.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.495308,
+ "gbest_acc": 84.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.493339,
+ "gbest_acc": 84.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.491167,
+ "gbest_acc": 84.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.490525,
+ "gbest_acc": 84.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.485086,
+ "gbest_acc": 84.7,
+ "val_loss": 0.54033,
+ "val_acc": 82.96
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.485086,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.484207,
+ "gbest_acc": 84.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.48301,
+ "gbest_acc": 84.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.48298,
+ "gbest_acc": 85.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.48298,
+ "gbest_acc": 85.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.480706,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.479099,
+ "gbest_acc": 85.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.476034,
+ "gbest_acc": 85.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.474785,
+ "gbest_acc": 85.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.471015,
+ "gbest_acc": 85.55,
+ "val_loss": 0.533112,
+ "val_acc": 83.28
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.470914,
+ "gbest_acc": 85.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.470914,
+ "gbest_acc": 85.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46867,
+ "gbest_acc": 85.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46867,
+ "gbest_acc": 85.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46867,
+ "gbest_acc": 85.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46867,
+ "gbest_acc": 85.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46687,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46447,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.461641,
+ "gbest_acc": 85.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46143,
+ "gbest_acc": 85.5,
+ "val_loss": 0.522796,
+ "val_acc": 83.38
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.460968,
+ "gbest_acc": 85.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45852,
+ "gbest_acc": 85.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45745,
+ "gbest_acc": 85.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45567,
+ "gbest_acc": 85.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45567,
+ "gbest_acc": 85.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.455369,
+ "gbest_acc": 85.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.453665,
+ "gbest_acc": 86.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.453665,
+ "gbest_acc": 86.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45181,
+ "gbest_acc": 86.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.450547,
+ "gbest_acc": 86.45,
+ "val_loss": 0.520438,
+ "val_acc": 83.46
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.44695,
+ "gbest_acc": 86.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.443735,
+ "gbest_acc": 86.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.440839,
+ "gbest_acc": 86.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.440839,
+ "gbest_acc": 86.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.440154,
+ "gbest_acc": 86.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.439082,
+ "gbest_acc": 86.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.439082,
+ "gbest_acc": 86.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.43887,
+ "gbest_acc": 86.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.438058,
+ "gbest_acc": 86.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.434735,
+ "gbest_acc": 86.4,
+ "val_loss": 0.508354,
+ "val_acc": 83.96
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.434674,
+ "gbest_acc": 86.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.429255,
+ "gbest_acc": 86.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.429255,
+ "gbest_acc": 86.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.428858,
+ "gbest_acc": 86.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.42505,
+ "gbest_acc": 86.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.42505,
+ "gbest_acc": 86.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.424086,
+ "gbest_acc": 86.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.424086,
+ "gbest_acc": 86.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.424086,
+ "gbest_acc": 86.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.422646,
+ "gbest_acc": 86.75,
+ "val_loss": 0.498121,
+ "val_acc": 84.2
+ }
+ ],
+ "seed": 101,
+ "geometry_config": {
+ "config_id": "G6",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 1.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test broader normalized initialization"
+ }
+ },
+ {
+ "config_id": "G6",
+ "gbest_loss": 0.445977,
+ "gbest_acc": 86.25,
+ "gbest_val_loss": 0.522555,
+ "gbest_val_acc": 83.96,
+ "val_selected_particle_idx": 12,
+ "val_selected_loss": 0.521653,
+ "val_selected_acc": 84.06,
+ "val_metrics": {
+ "accuracy": 84.06,
+ "nll": 0.521653,
+ "brier": 0.236013,
+ "ece": 0.023118,
+ "margin": 0.711133
+ },
+ "wall_time_sec": 34.3861,
+ "optimization_wall_time_sec": 33.9531,
+ "validation_wall_time_sec": 0.433,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 513,
+ "final_moment_steps": [
+ 86,
+ 2,
+ 53,
+ 73,
+ 15,
+ 14,
+ 34,
+ 123,
+ 84,
+ 2,
+ 51,
+ 104,
+ 174,
+ 115,
+ 22,
+ 41,
+ 6,
+ 147,
+ 119,
+ 38,
+ 49,
+ 28,
+ 31,
+ 62,
+ 12,
+ 71,
+ 34,
+ 20,
+ 46,
+ 80,
+ 42,
+ 131,
+ 13,
+ 27,
+ 89,
+ 5,
+ 35,
+ 29,
+ 82,
+ 15,
+ 17,
+ 44,
+ 61,
+ 111,
+ 26,
+ 87,
+ 43,
+ 39,
+ 5,
+ 21,
+ 7,
+ 4,
+ 42,
+ 45,
+ 131,
+ 85,
+ 14,
+ 3,
+ 193,
+ 28
+ ],
+ "pbest_update_counts": 10360,
+ "boundary_hits": 352748,
+ "boundary_occupancy": 0.001539,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.175875,
+ "position_radius": 12.217265,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.325288,
+ "gbest_acc": 7.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.303698,
+ "gbest_acc": 10.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.276653,
+ "gbest_acc": 17.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.248022,
+ "gbest_acc": 20.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.191486,
+ "gbest_acc": 24.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.172964,
+ "gbest_acc": 23.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.140794,
+ "gbest_acc": 25.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.121751,
+ "gbest_acc": 25.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.121751,
+ "gbest_acc": 25.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.109673,
+ "gbest_acc": 25.05,
+ "val_loss": 2.106116,
+ "val_acc": 24.54
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.103431,
+ "gbest_acc": 26.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.08475,
+ "gbest_acc": 26.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.073097,
+ "gbest_acc": 30.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.046818,
+ "gbest_acc": 29.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.031539,
+ "gbest_acc": 31.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.017354,
+ "gbest_acc": 28.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.017354,
+ "gbest_acc": 28.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.003742,
+ "gbest_acc": 29.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.986837,
+ "gbest_acc": 31.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.944175,
+ "gbest_acc": 34.1,
+ "val_loss": 1.928924,
+ "val_acc": 34.51
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.944175,
+ "gbest_acc": 34.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.944175,
+ "gbest_acc": 34.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.944175,
+ "gbest_acc": 34.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.929495,
+ "gbest_acc": 32.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.884191,
+ "gbest_acc": 38.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883921,
+ "gbest_acc": 33.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883921,
+ "gbest_acc": 33.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883921,
+ "gbest_acc": 33.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883921,
+ "gbest_acc": 33.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.788107,
+ "gbest_acc": 39.8,
+ "val_loss": 1.784119,
+ "val_acc": 38.63
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.73959,
+ "gbest_acc": 41.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.73959,
+ "gbest_acc": 41.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.73959,
+ "gbest_acc": 41.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.734325,
+ "gbest_acc": 42.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.734325,
+ "gbest_acc": 42.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.734325,
+ "gbest_acc": 42.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.734325,
+ "gbest_acc": 42.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.703814,
+ "gbest_acc": 42.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.703814,
+ "gbest_acc": 42.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.670778,
+ "gbest_acc": 45.25,
+ "val_loss": 1.67181,
+ "val_acc": 44.56
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.670778,
+ "gbest_acc": 45.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.670778,
+ "gbest_acc": 45.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.670778,
+ "gbest_acc": 45.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.66898,
+ "gbest_acc": 44.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.642849,
+ "gbest_acc": 46.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.637721,
+ "gbest_acc": 45.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.6244,
+ "gbest_acc": 47.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.553537,
+ "gbest_acc": 51.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.553537,
+ "gbest_acc": 51.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.553537,
+ "gbest_acc": 51.75,
+ "val_loss": 1.576836,
+ "val_acc": 48.99
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.549802,
+ "gbest_acc": 51.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.545503,
+ "gbest_acc": 51.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.533125,
+ "gbest_acc": 49.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.510107,
+ "gbest_acc": 50.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.486493,
+ "gbest_acc": 53.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.486493,
+ "gbest_acc": 53.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.477362,
+ "gbest_acc": 51.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.477362,
+ "gbest_acc": 51.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.471616,
+ "gbest_acc": 51.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452964,
+ "gbest_acc": 52.25,
+ "val_loss": 1.480729,
+ "val_acc": 51.43
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452964,
+ "gbest_acc": 52.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452964,
+ "gbest_acc": 52.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.442052,
+ "gbest_acc": 54.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.409034,
+ "gbest_acc": 55.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.409034,
+ "gbest_acc": 55.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.39772,
+ "gbest_acc": 56.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.385634,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.378163,
+ "gbest_acc": 54.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.377544,
+ "gbest_acc": 55.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.377544,
+ "gbest_acc": 55.5,
+ "val_loss": 1.408721,
+ "val_acc": 54.17
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.377544,
+ "gbest_acc": 55.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.37149,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.37149,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.37149,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.36253,
+ "gbest_acc": 56.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.346272,
+ "gbest_acc": 56.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.345117,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.317858,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.296909,
+ "gbest_acc": 56.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.292817,
+ "gbest_acc": 57.5,
+ "val_loss": 1.318424,
+ "val_acc": 55.9
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.286676,
+ "gbest_acc": 57.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.283301,
+ "gbest_acc": 57.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.283301,
+ "gbest_acc": 57.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.271153,
+ "gbest_acc": 58.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.266194,
+ "gbest_acc": 58.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.266194,
+ "gbest_acc": 58.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.260438,
+ "gbest_acc": 58.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.255971,
+ "gbest_acc": 59.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.248075,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.248075,
+ "gbest_acc": 60.6,
+ "val_loss": 1.276369,
+ "val_acc": 57.49
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.234323,
+ "gbest_acc": 61.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.229701,
+ "gbest_acc": 59.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.208922,
+ "gbest_acc": 60.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199836,
+ "gbest_acc": 60.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199836,
+ "gbest_acc": 60.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199836,
+ "gbest_acc": 60.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.198708,
+ "gbest_acc": 61.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.19198,
+ "gbest_acc": 61.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.176048,
+ "gbest_acc": 62.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.176048,
+ "gbest_acc": 62.1,
+ "val_loss": 1.217381,
+ "val_acc": 59.72
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.176048,
+ "gbest_acc": 62.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.16197,
+ "gbest_acc": 62.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.154283,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.154283,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136477,
+ "gbest_acc": 63.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136477,
+ "gbest_acc": 63.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.124143,
+ "gbest_acc": 63.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12349,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106312,
+ "gbest_acc": 63.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.103874,
+ "gbest_acc": 64.9,
+ "val_loss": 1.140638,
+ "val_acc": 62.59
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.099498,
+ "gbest_acc": 64.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.091561,
+ "gbest_acc": 65.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.091267,
+ "gbest_acc": 64.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.084231,
+ "gbest_acc": 65.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.084231,
+ "gbest_acc": 65.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.057816,
+ "gbest_acc": 65.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.054417,
+ "gbest_acc": 65.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.054417,
+ "gbest_acc": 65.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.05095,
+ "gbest_acc": 66.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.034377,
+ "gbest_acc": 66.8,
+ "val_loss": 1.081776,
+ "val_acc": 64.55
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.029908,
+ "gbest_acc": 66.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.028048,
+ "gbest_acc": 66.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.028048,
+ "gbest_acc": 66.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.021766,
+ "gbest_acc": 66.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.017643,
+ "gbest_acc": 66.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.005748,
+ "gbest_acc": 66.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.988799,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.988799,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.987622,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.984837,
+ "gbest_acc": 67.45,
+ "val_loss": 1.031806,
+ "val_acc": 65.98
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.984837,
+ "gbest_acc": 67.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.979589,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.979589,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.979589,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.979589,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.977807,
+ "gbest_acc": 69.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974636,
+ "gbest_acc": 68.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.966236,
+ "gbest_acc": 69.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.960639,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.956944,
+ "gbest_acc": 68.55,
+ "val_loss": 1.006943,
+ "val_acc": 67.01
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.954276,
+ "gbest_acc": 68.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.951831,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.950283,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.94936,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.94936,
+ "gbest_acc": 68.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.933247,
+ "gbest_acc": 70.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.933247,
+ "gbest_acc": 70.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.933247,
+ "gbest_acc": 70.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.930519,
+ "gbest_acc": 69.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.927035,
+ "gbest_acc": 70.05,
+ "val_loss": 0.981369,
+ "val_acc": 67.55
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.925717,
+ "gbest_acc": 69.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.918329,
+ "gbest_acc": 70.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.918222,
+ "gbest_acc": 69.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.908461,
+ "gbest_acc": 70.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.908461,
+ "gbest_acc": 70.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.908461,
+ "gbest_acc": 70.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.908461,
+ "gbest_acc": 70.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.906102,
+ "gbest_acc": 70.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.901999,
+ "gbest_acc": 70.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.896034,
+ "gbest_acc": 70.45,
+ "val_loss": 0.944199,
+ "val_acc": 69.23
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.892707,
+ "gbest_acc": 70.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.885515,
+ "gbest_acc": 71.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.876059,
+ "gbest_acc": 72.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.876059,
+ "gbest_acc": 72.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.869043,
+ "gbest_acc": 72.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.8642,
+ "gbest_acc": 72.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.863646,
+ "gbest_acc": 71.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.863646,
+ "gbest_acc": 71.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858266,
+ "gbest_acc": 72.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.857081,
+ "gbest_acc": 72.4,
+ "val_loss": 0.902301,
+ "val_acc": 70.75
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.852685,
+ "gbest_acc": 72.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.852685,
+ "gbest_acc": 72.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.852685,
+ "gbest_acc": 72.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.852542,
+ "gbest_acc": 72.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.850971,
+ "gbest_acc": 72.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.848259,
+ "gbest_acc": 72.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.846991,
+ "gbest_acc": 71.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.845444,
+ "gbest_acc": 72.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.838591,
+ "gbest_acc": 73.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.837015,
+ "gbest_acc": 73.1,
+ "val_loss": 0.884214,
+ "val_acc": 71.43
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.835235,
+ "gbest_acc": 73.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.831122,
+ "gbest_acc": 72.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.823598,
+ "gbest_acc": 73.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.823598,
+ "gbest_acc": 73.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.815454,
+ "gbest_acc": 73.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.813775,
+ "gbest_acc": 73.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.808305,
+ "gbest_acc": 73.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.804288,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.801415,
+ "gbest_acc": 73.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.796196,
+ "gbest_acc": 73.55,
+ "val_loss": 0.835796,
+ "val_acc": 73.38
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.792457,
+ "gbest_acc": 73.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.792457,
+ "gbest_acc": 73.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.789858,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.789142,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.785265,
+ "gbest_acc": 74.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78388,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78388,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.78388,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.782898,
+ "gbest_acc": 73.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.781568,
+ "gbest_acc": 74.6,
+ "val_loss": 0.824822,
+ "val_acc": 73.21
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.781568,
+ "gbest_acc": 74.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.778735,
+ "gbest_acc": 74.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.776401,
+ "gbest_acc": 73.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.771081,
+ "gbest_acc": 74.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.770534,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.770534,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.769935,
+ "gbest_acc": 75.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.769135,
+ "gbest_acc": 74.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.769099,
+ "gbest_acc": 74.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.766928,
+ "gbest_acc": 74.5,
+ "val_loss": 0.811113,
+ "val_acc": 73.63
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.764188,
+ "gbest_acc": 74.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.762084,
+ "gbest_acc": 74.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758901,
+ "gbest_acc": 74.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.758497,
+ "gbest_acc": 74.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.755549,
+ "gbest_acc": 74.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.751707,
+ "gbest_acc": 75.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.750372,
+ "gbest_acc": 75.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.747836,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.74678,
+ "gbest_acc": 74.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.741789,
+ "gbest_acc": 74.6,
+ "val_loss": 0.788696,
+ "val_acc": 74.53
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.740774,
+ "gbest_acc": 74.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.739077,
+ "gbest_acc": 75.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735081,
+ "gbest_acc": 75.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.734149,
+ "gbest_acc": 76.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.733514,
+ "gbest_acc": 76.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.731859,
+ "gbest_acc": 75.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.724221,
+ "gbest_acc": 76.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.724221,
+ "gbest_acc": 76.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.716669,
+ "gbest_acc": 77.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.711826,
+ "gbest_acc": 77.4,
+ "val_loss": 0.759753,
+ "val_acc": 76.04
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.710167,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706836,
+ "gbest_acc": 77.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.701938,
+ "gbest_acc": 77.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.698054,
+ "gbest_acc": 76.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.695105,
+ "gbest_acc": 77.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.69158,
+ "gbest_acc": 76.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688424,
+ "gbest_acc": 77.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688424,
+ "gbest_acc": 77.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.686306,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.685382,
+ "gbest_acc": 76.8,
+ "val_loss": 0.737589,
+ "val_acc": 76.72
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.685382,
+ "gbest_acc": 76.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.683925,
+ "gbest_acc": 77.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.682109,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.680607,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.678884,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.678884,
+ "gbest_acc": 77.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.67666,
+ "gbest_acc": 77.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.674999,
+ "gbest_acc": 78.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.67224,
+ "gbest_acc": 77.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.669672,
+ "gbest_acc": 77.95,
+ "val_loss": 0.724393,
+ "val_acc": 76.95
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.668567,
+ "gbest_acc": 78.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.666558,
+ "gbest_acc": 78.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.665992,
+ "gbest_acc": 78.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.662464,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.65953,
+ "gbest_acc": 78.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.656542,
+ "gbest_acc": 78.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.653171,
+ "gbest_acc": 78.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.648471,
+ "gbest_acc": 78.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.648471,
+ "gbest_acc": 78.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.645465,
+ "gbest_acc": 78.4,
+ "val_loss": 0.697154,
+ "val_acc": 77.84
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.644427,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.643076,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.640417,
+ "gbest_acc": 79.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.638892,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.637482,
+ "gbest_acc": 79.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.637482,
+ "gbest_acc": 79.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.634832,
+ "gbest_acc": 79.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.633014,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.630339,
+ "gbest_acc": 79.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.62894,
+ "gbest_acc": 79.0,
+ "val_loss": 0.681489,
+ "val_acc": 78.34
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.628284,
+ "gbest_acc": 79.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.625183,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.621625,
+ "gbest_acc": 79.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.621625,
+ "gbest_acc": 79.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.61983,
+ "gbest_acc": 79.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.618032,
+ "gbest_acc": 79.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.616925,
+ "gbest_acc": 80.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.614005,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.610711,
+ "gbest_acc": 80.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.610711,
+ "gbest_acc": 80.2,
+ "val_loss": 0.668245,
+ "val_acc": 78.89
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.609234,
+ "gbest_acc": 80.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.608982,
+ "gbest_acc": 80.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.606594,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602865,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602378,
+ "gbest_acc": 80.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602378,
+ "gbest_acc": 80.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.601283,
+ "gbest_acc": 81.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.600855,
+ "gbest_acc": 81.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.600411,
+ "gbest_acc": 80.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.598437,
+ "gbest_acc": 81.1,
+ "val_loss": 0.661099,
+ "val_acc": 79.18
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.596836,
+ "gbest_acc": 81.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.596836,
+ "gbest_acc": 81.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.595142,
+ "gbest_acc": 81.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.591796,
+ "gbest_acc": 81.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.590324,
+ "gbest_acc": 81.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.589051,
+ "gbest_acc": 81.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.586146,
+ "gbest_acc": 82.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.585059,
+ "gbest_acc": 82.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.584203,
+ "gbest_acc": 82.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.583769,
+ "gbest_acc": 82.3,
+ "val_loss": 0.651275,
+ "val_acc": 79.49
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.580835,
+ "gbest_acc": 82.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.579458,
+ "gbest_acc": 82.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.577584,
+ "gbest_acc": 82.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.574437,
+ "gbest_acc": 82.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.573828,
+ "gbest_acc": 82.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.57381,
+ "gbest_acc": 83.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.571863,
+ "gbest_acc": 82.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.571863,
+ "gbest_acc": 82.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.571619,
+ "gbest_acc": 82.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.570848,
+ "gbest_acc": 82.85,
+ "val_loss": 0.638731,
+ "val_acc": 79.96
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.570666,
+ "gbest_acc": 82.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.56817,
+ "gbest_acc": 83.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.563272,
+ "gbest_acc": 83.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.56232,
+ "gbest_acc": 83.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.561597,
+ "gbest_acc": 83.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.560461,
+ "gbest_acc": 82.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.558205,
+ "gbest_acc": 83.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.555244,
+ "gbest_acc": 83.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.55464,
+ "gbest_acc": 83.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.550151,
+ "gbest_acc": 83.1,
+ "val_loss": 0.615959,
+ "val_acc": 81.23
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.550151,
+ "gbest_acc": 83.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.548698,
+ "gbest_acc": 83.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.54816,
+ "gbest_acc": 83.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.544434,
+ "gbest_acc": 83.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.544434,
+ "gbest_acc": 83.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.543106,
+ "gbest_acc": 83.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.541154,
+ "gbest_acc": 84.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.540851,
+ "gbest_acc": 83.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.538607,
+ "gbest_acc": 84.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.537797,
+ "gbest_acc": 83.9,
+ "val_loss": 0.604792,
+ "val_acc": 81.54
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.535332,
+ "gbest_acc": 84.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.534784,
+ "gbest_acc": 84.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.534089,
+ "gbest_acc": 84.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.532754,
+ "gbest_acc": 84.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.53149,
+ "gbest_acc": 84.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.530315,
+ "gbest_acc": 84.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.528484,
+ "gbest_acc": 84.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.528192,
+ "gbest_acc": 84.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.527164,
+ "gbest_acc": 84.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.527164,
+ "gbest_acc": 84.55,
+ "val_loss": 0.59389,
+ "val_acc": 81.58
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.526054,
+ "gbest_acc": 84.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.524198,
+ "gbest_acc": 84.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.523139,
+ "gbest_acc": 84.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.521735,
+ "gbest_acc": 84.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.52005,
+ "gbest_acc": 84.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.516831,
+ "gbest_acc": 84.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.515759,
+ "gbest_acc": 84.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.514715,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.50993,
+ "gbest_acc": 84.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.509338,
+ "gbest_acc": 84.4,
+ "val_loss": 0.582765,
+ "val_acc": 82.1
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.508564,
+ "gbest_acc": 84.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.506913,
+ "gbest_acc": 84.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.505721,
+ "gbest_acc": 84.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.505616,
+ "gbest_acc": 84.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.50439,
+ "gbest_acc": 84.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.503066,
+ "gbest_acc": 84.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.503066,
+ "gbest_acc": 84.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.500892,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.500488,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.498776,
+ "gbest_acc": 84.75,
+ "val_loss": 0.568354,
+ "val_acc": 82.41
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.496492,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.496492,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.496492,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.496492,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.495745,
+ "gbest_acc": 85.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.494404,
+ "gbest_acc": 85.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.493262,
+ "gbest_acc": 84.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.492086,
+ "gbest_acc": 85.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.491378,
+ "gbest_acc": 85.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.491148,
+ "gbest_acc": 85.0,
+ "val_loss": 0.563188,
+ "val_acc": 82.45
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.489963,
+ "gbest_acc": 85.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.48741,
+ "gbest_acc": 85.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.486137,
+ "gbest_acc": 85.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.485637,
+ "gbest_acc": 85.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.485079,
+ "gbest_acc": 85.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.484796,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.483306,
+ "gbest_acc": 85.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.483306,
+ "gbest_acc": 85.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.483306,
+ "gbest_acc": 85.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.482219,
+ "gbest_acc": 85.3,
+ "val_loss": 0.557157,
+ "val_acc": 82.74
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.481403,
+ "gbest_acc": 85.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.47944,
+ "gbest_acc": 85.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.478898,
+ "gbest_acc": 85.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.477553,
+ "gbest_acc": 85.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.474834,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.474834,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.474267,
+ "gbest_acc": 85.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.473395,
+ "gbest_acc": 85.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.472181,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.471634,
+ "gbest_acc": 86.0,
+ "val_loss": 0.547718,
+ "val_acc": 83.04
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.470744,
+ "gbest_acc": 86.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.469306,
+ "gbest_acc": 86.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.4693,
+ "gbest_acc": 85.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.468882,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.467515,
+ "gbest_acc": 86.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.466903,
+ "gbest_acc": 86.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.466347,
+ "gbest_acc": 86.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.464838,
+ "gbest_acc": 86.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.464113,
+ "gbest_acc": 86.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.463231,
+ "gbest_acc": 86.1,
+ "val_loss": 0.538985,
+ "val_acc": 83.57
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.461511,
+ "gbest_acc": 85.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46043,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.459881,
+ "gbest_acc": 86.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.459451,
+ "gbest_acc": 86.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.459334,
+ "gbest_acc": 86.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.459334,
+ "gbest_acc": 86.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.457651,
+ "gbest_acc": 85.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.455155,
+ "gbest_acc": 86.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45437,
+ "gbest_acc": 86.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.453744,
+ "gbest_acc": 86.5,
+ "val_loss": 0.529059,
+ "val_acc": 83.75
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.453374,
+ "gbest_acc": 86.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.452051,
+ "gbest_acc": 86.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.450578,
+ "gbest_acc": 86.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.450063,
+ "gbest_acc": 86.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.449675,
+ "gbest_acc": 86.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.44872,
+ "gbest_acc": 87.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.448166,
+ "gbest_acc": 86.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.445977,
+ "gbest_acc": 86.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.445977,
+ "gbest_acc": 86.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.445977,
+ "gbest_acc": 86.25,
+ "val_loss": 0.522555,
+ "val_acc": 83.96
+ }
+ ],
+ "seed": 102,
+ "geometry_config": {
+ "config_id": "G6",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 1.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test broader normalized initialization"
+ }
+ },
+ {
+ "config_id": "G6",
+ "gbest_loss": 0.420119,
+ "gbest_acc": 87.4,
+ "gbest_val_loss": 0.493078,
+ "gbest_val_acc": 84.69,
+ "val_selected_particle_idx": 4,
+ "val_selected_loss": 0.491652,
+ "val_selected_acc": 84.49,
+ "val_metrics": {
+ "accuracy": 84.49,
+ "nll": 0.491652,
+ "brier": 0.226617,
+ "ece": 0.010903,
+ "margin": 0.741913
+ },
+ "wall_time_sec": 35.4402,
+ "optimization_wall_time_sec": 34.9982,
+ "validation_wall_time_sec": 0.4419,
+ "total_queries": 25200,
+ "total_sample_evaluations": 50400000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 103,
+ "official_test_evaluations": 0,
+ "mutation_events": 520,
+ "final_moment_steps": [
+ 37,
+ 54,
+ 23,
+ 120,
+ 78,
+ 5,
+ 133,
+ 90,
+ 97,
+ 5,
+ 31,
+ 207,
+ 48,
+ 70,
+ 25,
+ 1,
+ 52,
+ 23,
+ 37,
+ 13,
+ 1,
+ 28,
+ 7,
+ 70,
+ 24,
+ 65,
+ 20,
+ 45,
+ 75,
+ 99,
+ 1,
+ 111,
+ 40,
+ 19,
+ 75,
+ 38,
+ 10,
+ 41,
+ 84,
+ 50,
+ 4,
+ 12,
+ 54,
+ 13,
+ 117,
+ 22,
+ 12,
+ 55,
+ 29,
+ 58,
+ 40,
+ 57,
+ 49,
+ 43,
+ 166,
+ 108,
+ 54,
+ 34,
+ 44,
+ 27
+ ],
+ "pbest_update_counts": 9249,
+ "boundary_hits": 399064,
+ "boundary_occupancy": 0.001741,
+ "last_improvement_epoch": 420,
+ "velocity_rms": 0.113773,
+ "position_radius": 8.452122,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.287914,
+ "gbest_acc": 14.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.284861,
+ "gbest_acc": 15.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.257874,
+ "gbest_acc": 15.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.231976,
+ "gbest_acc": 18.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.210336,
+ "gbest_acc": 16.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.19479,
+ "gbest_acc": 14.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.177079,
+ "gbest_acc": 16.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.158732,
+ "gbest_acc": 19.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.158732,
+ "gbest_acc": 19.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.158732,
+ "gbest_acc": 19.7,
+ "val_loss": 2.145256,
+ "val_acc": 20.11
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.152148,
+ "gbest_acc": 18.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.081408,
+ "gbest_acc": 21.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.025574,
+ "gbest_acc": 24.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.025574,
+ "gbest_acc": 24.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.006338,
+ "gbest_acc": 28.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.006338,
+ "gbest_acc": 28.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.952874,
+ "gbest_acc": 32.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.952874,
+ "gbest_acc": 32.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.952874,
+ "gbest_acc": 32.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.952874,
+ "gbest_acc": 32.05,
+ "val_loss": 1.934467,
+ "val_acc": 32.55
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.891713,
+ "gbest_acc": 31.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.879687,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.879687,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.879687,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.860288,
+ "gbest_acc": 35.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.850561,
+ "gbest_acc": 37.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.840237,
+ "gbest_acc": 36.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.83021,
+ "gbest_acc": 35.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.822399,
+ "gbest_acc": 34.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.805009,
+ "gbest_acc": 38.35,
+ "val_loss": 1.775587,
+ "val_acc": 39.66
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.798626,
+ "gbest_acc": 37.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.798626,
+ "gbest_acc": 37.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.77093,
+ "gbest_acc": 37.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.752763,
+ "gbest_acc": 39.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.751739,
+ "gbest_acc": 39.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.751083,
+ "gbest_acc": 39.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.750646,
+ "gbest_acc": 39.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.749304,
+ "gbest_acc": 38.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.731727,
+ "gbest_acc": 39.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.731727,
+ "gbest_acc": 39.7,
+ "val_loss": 1.702245,
+ "val_acc": 41.38
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.729065,
+ "gbest_acc": 39.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.729065,
+ "gbest_acc": 39.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.703436,
+ "gbest_acc": 40.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.703436,
+ "gbest_acc": 40.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.703436,
+ "gbest_acc": 40.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.679256,
+ "gbest_acc": 39.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.657955,
+ "gbest_acc": 41.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.657955,
+ "gbest_acc": 41.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.656874,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.644688,
+ "gbest_acc": 45.0,
+ "val_loss": 1.619296,
+ "val_acc": 46.47
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.644688,
+ "gbest_acc": 45.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.633229,
+ "gbest_acc": 46.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.62915,
+ "gbest_acc": 44.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.615447,
+ "gbest_acc": 45.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.588456,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.588456,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.588456,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.588456,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.571952,
+ "gbest_acc": 45.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.571941,
+ "gbest_acc": 46.2,
+ "val_loss": 1.553717,
+ "val_acc": 47.32
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.567404,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.565136,
+ "gbest_acc": 48.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.547803,
+ "gbest_acc": 47.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.523299,
+ "gbest_acc": 49.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.522494,
+ "gbest_acc": 48.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.506741,
+ "gbest_acc": 48.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.493979,
+ "gbest_acc": 47.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.487447,
+ "gbest_acc": 49.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.487447,
+ "gbest_acc": 49.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.475406,
+ "gbest_acc": 48.95,
+ "val_loss": 1.46026,
+ "val_acc": 50.11
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.456636,
+ "gbest_acc": 50.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.436346,
+ "gbest_acc": 52.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.436346,
+ "gbest_acc": 52.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.434191,
+ "gbest_acc": 50.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.414346,
+ "gbest_acc": 51.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.413534,
+ "gbest_acc": 51.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.40719,
+ "gbest_acc": 50.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401994,
+ "gbest_acc": 51.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.394808,
+ "gbest_acc": 51.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.380568,
+ "gbest_acc": 52.3,
+ "val_loss": 1.375089,
+ "val_acc": 52.3
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.380568,
+ "gbest_acc": 52.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348019,
+ "gbest_acc": 54.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348019,
+ "gbest_acc": 54.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348019,
+ "gbest_acc": 54.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.333347,
+ "gbest_acc": 56.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.322313,
+ "gbest_acc": 54.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.309068,
+ "gbest_acc": 55.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.29399,
+ "gbest_acc": 56.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.29399,
+ "gbest_acc": 56.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.29399,
+ "gbest_acc": 56.8,
+ "val_loss": 1.27277,
+ "val_acc": 58.55
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.29399,
+ "gbest_acc": 56.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.285032,
+ "gbest_acc": 58.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279089,
+ "gbest_acc": 57.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.27246,
+ "gbest_acc": 59.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.260669,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.247211,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.228372,
+ "gbest_acc": 57.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.225919,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.206558,
+ "gbest_acc": 58.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199931,
+ "gbest_acc": 59.35,
+ "val_loss": 1.20981,
+ "val_acc": 59.57
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.168667,
+ "gbest_acc": 60.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.168667,
+ "gbest_acc": 60.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.152839,
+ "gbest_acc": 61.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.152839,
+ "gbest_acc": 61.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.152553,
+ "gbest_acc": 61.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.144903,
+ "gbest_acc": 61.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.128972,
+ "gbest_acc": 61.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.118429,
+ "gbest_acc": 61.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.109975,
+ "gbest_acc": 62.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.109975,
+ "gbest_acc": 62.25,
+ "val_loss": 1.133655,
+ "val_acc": 61.7
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.109975,
+ "gbest_acc": 62.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.108882,
+ "gbest_acc": 62.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.102237,
+ "gbest_acc": 62.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.092858,
+ "gbest_acc": 62.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.092858,
+ "gbest_acc": 62.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.086137,
+ "gbest_acc": 62.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.086137,
+ "gbest_acc": 62.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.086137,
+ "gbest_acc": 62.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.076643,
+ "gbest_acc": 63.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.065412,
+ "gbest_acc": 63.3,
+ "val_loss": 1.088712,
+ "val_acc": 63.41
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.065412,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.064086,
+ "gbest_acc": 64.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.053645,
+ "gbest_acc": 64.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.051744,
+ "gbest_acc": 63.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.031056,
+ "gbest_acc": 65.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.031056,
+ "gbest_acc": 65.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.031056,
+ "gbest_acc": 65.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.030808,
+ "gbest_acc": 64.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.024108,
+ "gbest_acc": 65.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.020005,
+ "gbest_acc": 64.9,
+ "val_loss": 1.031538,
+ "val_acc": 65.24
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.020005,
+ "gbest_acc": 64.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.017716,
+ "gbest_acc": 65.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.017716,
+ "gbest_acc": 65.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.010425,
+ "gbest_acc": 65.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.002559,
+ "gbest_acc": 65.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.994548,
+ "gbest_acc": 66.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974724,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974724,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.974724,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.969618,
+ "gbest_acc": 67.8,
+ "val_loss": 0.987995,
+ "val_acc": 67.43
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.963238,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.951412,
+ "gbest_acc": 68.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.945568,
+ "gbest_acc": 69.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.945568,
+ "gbest_acc": 69.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.93983,
+ "gbest_acc": 68.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92914,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.919187,
+ "gbest_acc": 69.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.916826,
+ "gbest_acc": 69.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.916826,
+ "gbest_acc": 69.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.916826,
+ "gbest_acc": 69.8,
+ "val_loss": 0.932437,
+ "val_acc": 68.51
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.908718,
+ "gbest_acc": 69.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.904786,
+ "gbest_acc": 70.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.904786,
+ "gbest_acc": 70.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.894028,
+ "gbest_acc": 71.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.885905,
+ "gbest_acc": 70.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884862,
+ "gbest_acc": 71.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884862,
+ "gbest_acc": 71.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882919,
+ "gbest_acc": 70.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.882177,
+ "gbest_acc": 70.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.878755,
+ "gbest_acc": 70.7,
+ "val_loss": 0.900997,
+ "val_acc": 70.15
+ },
+ {
+ "epoch": 161,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.869227,
+ "gbest_acc": 71.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 162,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.868265,
+ "gbest_acc": 71.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 163,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.859778,
+ "gbest_acc": 72.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 164,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.858541,
+ "gbest_acc": 72.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 165,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.849589,
+ "gbest_acc": 73.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 166,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.847409,
+ "gbest_acc": 72.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 167,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.845293,
+ "gbest_acc": 72.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 168,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.842278,
+ "gbest_acc": 72.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 169,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.840868,
+ "gbest_acc": 73.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 170,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.839781,
+ "gbest_acc": 72.8,
+ "val_loss": 0.860269,
+ "val_acc": 72.08
+ },
+ {
+ "epoch": 171,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.839781,
+ "gbest_acc": 72.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 172,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.837365,
+ "gbest_acc": 72.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 173,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.837197,
+ "gbest_acc": 73.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 174,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.835056,
+ "gbest_acc": 73.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 175,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.832937,
+ "gbest_acc": 73.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 176,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.832094,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 177,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.832094,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 178,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.832094,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 179,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.832094,
+ "gbest_acc": 73.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 180,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.828265,
+ "gbest_acc": 72.6,
+ "val_loss": 0.849009,
+ "val_acc": 71.76
+ },
+ {
+ "epoch": 181,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.823636,
+ "gbest_acc": 72.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 182,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.817271,
+ "gbest_acc": 74.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 183,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.815512,
+ "gbest_acc": 73.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 184,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.815512,
+ "gbest_acc": 73.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 185,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.810766,
+ "gbest_acc": 73.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 186,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.809745,
+ "gbest_acc": 74.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 187,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.803486,
+ "gbest_acc": 73.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 188,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.801068,
+ "gbest_acc": 74.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 189,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.798575,
+ "gbest_acc": 73.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 190,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.795113,
+ "gbest_acc": 74.25,
+ "val_loss": 0.826001,
+ "val_acc": 73.08
+ },
+ {
+ "epoch": 191,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.787875,
+ "gbest_acc": 74.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 192,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.787875,
+ "gbest_acc": 74.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 193,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.786744,
+ "gbest_acc": 74.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 194,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.786695,
+ "gbest_acc": 74.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 195,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.770591,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 196,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.770591,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 197,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.764087,
+ "gbest_acc": 74.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 198,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.759807,
+ "gbest_acc": 74.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 199,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.755596,
+ "gbest_acc": 75.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 200,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.750046,
+ "gbest_acc": 75.0,
+ "val_loss": 0.773975,
+ "val_acc": 74.29
+ },
+ {
+ "epoch": 201,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.746437,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 202,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.740099,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 203,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.740099,
+ "gbest_acc": 75.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 204,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735987,
+ "gbest_acc": 75.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 205,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735987,
+ "gbest_acc": 75.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 206,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735987,
+ "gbest_acc": 75.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 207,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.735663,
+ "gbest_acc": 75.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 208,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725156,
+ "gbest_acc": 76.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 209,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.725156,
+ "gbest_acc": 76.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 210,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.722473,
+ "gbest_acc": 76.6,
+ "val_loss": 0.75671,
+ "val_acc": 75.22
+ },
+ {
+ "epoch": 211,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.713871,
+ "gbest_acc": 77.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 212,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.709491,
+ "gbest_acc": 77.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 213,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.706839,
+ "gbest_acc": 77.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 214,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.701806,
+ "gbest_acc": 77.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 215,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.699974,
+ "gbest_acc": 77.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 216,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.697562,
+ "gbest_acc": 78.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 217,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.693024,
+ "gbest_acc": 77.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 218,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688156,
+ "gbest_acc": 78.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 219,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.688156,
+ "gbest_acc": 78.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 220,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.684955,
+ "gbest_acc": 78.0,
+ "val_loss": 0.723987,
+ "val_acc": 76.36
+ },
+ {
+ "epoch": 221,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.681628,
+ "gbest_acc": 78.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 222,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.678168,
+ "gbest_acc": 78.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 223,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.675446,
+ "gbest_acc": 78.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 224,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.675446,
+ "gbest_acc": 78.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 225,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.675446,
+ "gbest_acc": 78.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 226,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.675446,
+ "gbest_acc": 78.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 227,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.668731,
+ "gbest_acc": 78.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 228,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.664895,
+ "gbest_acc": 78.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 229,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.659519,
+ "gbest_acc": 78.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 230,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.655713,
+ "gbest_acc": 79.0,
+ "val_loss": 0.695629,
+ "val_acc": 76.95
+ },
+ {
+ "epoch": 231,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.655713,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 232,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.655713,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 233,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.651147,
+ "gbest_acc": 79.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 234,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.645809,
+ "gbest_acc": 79.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 235,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.640802,
+ "gbest_acc": 79.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 236,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.639458,
+ "gbest_acc": 79.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 237,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.637129,
+ "gbest_acc": 80.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 238,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.636579,
+ "gbest_acc": 80.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 239,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.632614,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 240,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.632614,
+ "gbest_acc": 80.65,
+ "val_loss": 0.6647,
+ "val_acc": 78.43
+ },
+ {
+ "epoch": 241,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.631752,
+ "gbest_acc": 80.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 242,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.631602,
+ "gbest_acc": 80.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 243,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.631602,
+ "gbest_acc": 80.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 244,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.629122,
+ "gbest_acc": 80.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 245,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.627725,
+ "gbest_acc": 80.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 246,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.624022,
+ "gbest_acc": 81.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 247,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.62057,
+ "gbest_acc": 80.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 248,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.617697,
+ "gbest_acc": 80.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 249,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.616975,
+ "gbest_acc": 80.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 250,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.613018,
+ "gbest_acc": 80.75,
+ "val_loss": 0.649444,
+ "val_acc": 79.18
+ },
+ {
+ "epoch": 251,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.611872,
+ "gbest_acc": 80.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 252,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.60825,
+ "gbest_acc": 80.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 253,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.605613,
+ "gbest_acc": 81.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 254,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.605613,
+ "gbest_acc": 81.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 255,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.605613,
+ "gbest_acc": 81.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 256,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.604953,
+ "gbest_acc": 80.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 257,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.602405,
+ "gbest_acc": 81.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 258,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.599034,
+ "gbest_acc": 81.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 259,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.599034,
+ "gbest_acc": 81.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 260,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.599034,
+ "gbest_acc": 81.9,
+ "val_loss": 0.638915,
+ "val_acc": 79.5
+ },
+ {
+ "epoch": 261,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.597399,
+ "gbest_acc": 81.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 262,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.593448,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 263,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.593448,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 264,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.593448,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 265,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.593448,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 266,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.593448,
+ "gbest_acc": 82.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 267,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.589572,
+ "gbest_acc": 81.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 268,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.585296,
+ "gbest_acc": 81.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 269,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.582099,
+ "gbest_acc": 81.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 270,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.578287,
+ "gbest_acc": 81.75,
+ "val_loss": 0.620615,
+ "val_acc": 79.85
+ },
+ {
+ "epoch": 271,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.575666,
+ "gbest_acc": 81.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 272,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.57408,
+ "gbest_acc": 81.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 273,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.57219,
+ "gbest_acc": 82.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 274,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.569981,
+ "gbest_acc": 82.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 275,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.566315,
+ "gbest_acc": 82.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 276,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.566315,
+ "gbest_acc": 82.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 277,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.566315,
+ "gbest_acc": 82.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 278,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.564921,
+ "gbest_acc": 82.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 279,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.564021,
+ "gbest_acc": 83.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 280,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.564021,
+ "gbest_acc": 83.05,
+ "val_loss": 0.611336,
+ "val_acc": 80.22
+ },
+ {
+ "epoch": 281,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.562219,
+ "gbest_acc": 82.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 282,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.558433,
+ "gbest_acc": 82.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 283,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.555449,
+ "gbest_acc": 82.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 284,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.555449,
+ "gbest_acc": 82.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 285,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.555449,
+ "gbest_acc": 82.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 286,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.554474,
+ "gbest_acc": 83.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 287,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.554031,
+ "gbest_acc": 82.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 288,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.551819,
+ "gbest_acc": 83.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 289,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.551455,
+ "gbest_acc": 83.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 290,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.550846,
+ "gbest_acc": 83.4,
+ "val_loss": 0.598677,
+ "val_acc": 80.92
+ },
+ {
+ "epoch": 291,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.549813,
+ "gbest_acc": 83.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 292,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.548705,
+ "gbest_acc": 83.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 293,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.546439,
+ "gbest_acc": 83.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 294,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.54545,
+ "gbest_acc": 83.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 295,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.545245,
+ "gbest_acc": 82.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 296,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.544553,
+ "gbest_acc": 82.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 297,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.543399,
+ "gbest_acc": 83.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 298,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.542148,
+ "gbest_acc": 83.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 299,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.539621,
+ "gbest_acc": 83.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 300,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.537986,
+ "gbest_acc": 83.35,
+ "val_loss": 0.585166,
+ "val_acc": 81.2
+ },
+ {
+ "epoch": 301,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.536046,
+ "gbest_acc": 83.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 302,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.535593,
+ "gbest_acc": 83.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 303,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.533016,
+ "gbest_acc": 83.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 304,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.532133,
+ "gbest_acc": 83.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 305,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.529391,
+ "gbest_acc": 83.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 306,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.52784,
+ "gbest_acc": 83.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 307,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.52642,
+ "gbest_acc": 83.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 308,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.523822,
+ "gbest_acc": 83.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 309,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.523234,
+ "gbest_acc": 83.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 310,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.522248,
+ "gbest_acc": 83.85,
+ "val_loss": 0.573425,
+ "val_acc": 81.53
+ },
+ {
+ "epoch": 311,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.520903,
+ "gbest_acc": 83.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 312,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.517646,
+ "gbest_acc": 83.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 313,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.515345,
+ "gbest_acc": 84.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 314,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.513799,
+ "gbest_acc": 83.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 315,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.511408,
+ "gbest_acc": 83.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 316,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.509953,
+ "gbest_acc": 84.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 317,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.508404,
+ "gbest_acc": 84.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 318,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.50606,
+ "gbest_acc": 84.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 319,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.504511,
+ "gbest_acc": 84.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 320,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.504511,
+ "gbest_acc": 84.15,
+ "val_loss": 0.566322,
+ "val_acc": 81.97
+ },
+ {
+ "epoch": 321,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.504511,
+ "gbest_acc": 84.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 322,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.504511,
+ "gbest_acc": 84.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 323,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.504327,
+ "gbest_acc": 84.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 324,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.502215,
+ "gbest_acc": 84.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 325,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.501235,
+ "gbest_acc": 84.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 326,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.500216,
+ "gbest_acc": 84.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 327,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.497499,
+ "gbest_acc": 84.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 328,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.495728,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 329,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.493185,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 330,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.490557,
+ "gbest_acc": 85.05,
+ "val_loss": 0.554143,
+ "val_acc": 82.6
+ },
+ {
+ "epoch": 331,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.490557,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 332,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.489693,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 333,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.488131,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 334,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.488131,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 335,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.488131,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 336,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.48757,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 337,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.485982,
+ "gbest_acc": 85.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 338,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.485982,
+ "gbest_acc": 85.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 339,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.484678,
+ "gbest_acc": 84.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 340,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.481946,
+ "gbest_acc": 85.5,
+ "val_loss": 0.541951,
+ "val_acc": 82.7
+ },
+ {
+ "epoch": 341,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.481946,
+ "gbest_acc": 85.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 342,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.480984,
+ "gbest_acc": 85.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 343,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.479491,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 344,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.479491,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 345,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.478937,
+ "gbest_acc": 85.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 346,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.478241,
+ "gbest_acc": 85.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 347,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.477824,
+ "gbest_acc": 84.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 348,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.477006,
+ "gbest_acc": 84.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 349,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.474777,
+ "gbest_acc": 84.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 350,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.474777,
+ "gbest_acc": 84.75,
+ "val_loss": 0.533911,
+ "val_acc": 82.99
+ },
+ {
+ "epoch": 351,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.473978,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 352,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.473374,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 353,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.471391,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 354,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.471391,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 355,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46775,
+ "gbest_acc": 85.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 356,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46775,
+ "gbest_acc": 85.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 357,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46775,
+ "gbest_acc": 85.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 358,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.466749,
+ "gbest_acc": 85.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 359,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.465831,
+ "gbest_acc": 85.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 360,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.464809,
+ "gbest_acc": 85.55,
+ "val_loss": 0.536025,
+ "val_acc": 82.98
+ },
+ {
+ "epoch": 361,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.46365,
+ "gbest_acc": 86.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 362,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.462189,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 363,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.462189,
+ "gbest_acc": 85.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 364,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.461524,
+ "gbest_acc": 85.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 365,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45863,
+ "gbest_acc": 85.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 366,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45863,
+ "gbest_acc": 85.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 367,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.456442,
+ "gbest_acc": 85.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 368,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.455763,
+ "gbest_acc": 85.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 369,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.455056,
+ "gbest_acc": 86.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 370,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45252,
+ "gbest_acc": 86.05,
+ "val_loss": 0.517162,
+ "val_acc": 83.78
+ },
+ {
+ "epoch": 371,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.45252,
+ "gbest_acc": 86.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 372,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.452488,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 373,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.451704,
+ "gbest_acc": 85.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 374,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.451704,
+ "gbest_acc": 85.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 375,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.451151,
+ "gbest_acc": 85.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 376,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.450202,
+ "gbest_acc": 85.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 377,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.450202,
+ "gbest_acc": 85.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 378,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.449674,
+ "gbest_acc": 86.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 379,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.449674,
+ "gbest_acc": 86.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 380,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.448594,
+ "gbest_acc": 86.1,
+ "val_loss": 0.51607,
+ "val_acc": 83.72
+ },
+ {
+ "epoch": 381,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.446736,
+ "gbest_acc": 86.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 382,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.446657,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 383,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.445496,
+ "gbest_acc": 85.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 384,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.445245,
+ "gbest_acc": 85.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 385,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.444815,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 386,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.444815,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 387,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.444815,
+ "gbest_acc": 85.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 388,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.44432,
+ "gbest_acc": 86.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 389,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.443104,
+ "gbest_acc": 86.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 390,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.442378,
+ "gbest_acc": 85.95,
+ "val_loss": 0.506089,
+ "val_acc": 83.99
+ },
+ {
+ "epoch": 391,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.440645,
+ "gbest_acc": 86.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 392,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.440645,
+ "gbest_acc": 86.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 393,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.440639,
+ "gbest_acc": 86.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 394,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.440505,
+ "gbest_acc": 86.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 395,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.438168,
+ "gbest_acc": 86.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 396,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.4361,
+ "gbest_acc": 86.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 397,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.4361,
+ "gbest_acc": 86.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 398,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.434952,
+ "gbest_acc": 86.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 399,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.434952,
+ "gbest_acc": 86.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 400,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.434585,
+ "gbest_acc": 86.75,
+ "val_loss": 0.505165,
+ "val_acc": 84.13
+ },
+ {
+ "epoch": 401,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.433815,
+ "gbest_acc": 86.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 402,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.432554,
+ "gbest_acc": 86.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 403,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.43126,
+ "gbest_acc": 86.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 404,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.429984,
+ "gbest_acc": 86.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 405,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.429911,
+ "gbest_acc": 86.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 406,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.428561,
+ "gbest_acc": 86.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 407,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.428137,
+ "gbest_acc": 87.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 408,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.428137,
+ "gbest_acc": 87.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 409,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.428137,
+ "gbest_acc": 87.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 410,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.426939,
+ "gbest_acc": 87.05,
+ "val_loss": 0.501554,
+ "val_acc": 84.3
+ },
+ {
+ "epoch": 411,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.426853,
+ "gbest_acc": 87.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 412,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.426061,
+ "gbest_acc": 87.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 413,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.425562,
+ "gbest_acc": 87.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 414,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.425114,
+ "gbest_acc": 87.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 415,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.424224,
+ "gbest_acc": 87.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 416,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.422623,
+ "gbest_acc": 87.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 417,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.421628,
+ "gbest_acc": 87.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 418,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.421592,
+ "gbest_acc": 87.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 419,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.420878,
+ "gbest_acc": 87.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 420,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.420119,
+ "gbest_acc": 87.4,
+ "val_loss": 0.493078,
+ "val_acc": 84.69
+ }
+ ],
+ "seed": 103,
+ "geometry_config": {
+ "config_id": "G6",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 1.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test broader normalized initialization"
+ }
+ }
+ ]
+ },
+ "confirm_aggregates": {
+ "G0": {
+ "val_selected_acc": {
+ "mean": 79.526667,
+ "std": 0.576397,
+ "median": 79.31,
+ "iqr": 0.545,
+ "ci95_t": 1.431865
+ },
+ "val_selected_nll": {
+ "mean": 0.689687,
+ "std": 0.008079,
+ "median": 0.685428,
+ "iqr": 0.007188,
+ "ci95_t": 0.02007
+ },
+ "brier": {
+ "mean": 0.31426,
+ "std": 0.002242,
+ "median": 0.314848,
+ "iqr": 0.002184,
+ "ci95_t": 0.00557
+ },
+ "ece": {
+ "mean": 0.119583,
+ "std": 0.012882,
+ "median": 0.116395,
+ "iqr": 0.012583,
+ "ci95_t": 0.032002
+ },
+ "num_seeds": 3
+ },
+ "G1": {
+ "val_selected_acc": {
+ "mean": 76.953333,
+ "std": 2.490067,
+ "median": 76.77,
+ "iqr": 2.485,
+ "ci95_t": 6.185737
+ },
+ "val_selected_nll": {
+ "mean": 0.833759,
+ "std": 0.123667,
+ "median": 0.829049,
+ "iqr": 0.123599,
+ "ci95_t": 0.307209
+ },
+ "brier": {
+ "mean": 0.376709,
+ "std": 0.05346,
+ "median": 0.371229,
+ "iqr": 0.053249,
+ "ci95_t": 0.132804
+ },
+ "ece": {
+ "mean": 0.189738,
+ "std": 0.042245,
+ "median": 0.179234,
+ "iqr": 0.041254,
+ "ci95_t": 0.104944
+ },
+ "num_seeds": 3
+ },
+ "G8": {
+ "val_selected_acc": {
+ "mean": 84.916667,
+ "std": 0.988804,
+ "median": 84.47,
+ "iqr": 0.91,
+ "ci95_t": 2.456352
+ },
+ "val_selected_nll": {
+ "mean": 0.48144,
+ "std": 0.029447,
+ "median": 0.492543,
+ "iqr": 0.027833,
+ "ci95_t": 0.073151
+ },
+ "brier": {
+ "mean": 0.221187,
+ "std": 0.012452,
+ "median": 0.226311,
+ "iqr": 0.011634,
+ "ci95_t": 0.030933
+ },
+ "ece": {
+ "mean": 0.014356,
+ "std": 0.006717,
+ "median": 0.01607,
+ "iqr": 0.00655,
+ "ci95_t": 0.016685
+ },
+ "num_seeds": 3
+ },
+ "G5": {
+ "val_selected_acc": {
+ "mean": 84.236667,
+ "std": 0.903678,
+ "median": 83.73,
+ "iqr": 0.79,
+ "ci95_t": 2.244884
+ },
+ "val_selected_nll": {
+ "mean": 0.510297,
+ "std": 0.024899,
+ "median": 0.519183,
+ "iqr": 0.023679,
+ "ci95_t": 0.061852
+ },
+ "brier": {
+ "mean": 0.231623,
+ "std": 0.01088,
+ "median": 0.237264,
+ "iqr": 0.009721,
+ "ci95_t": 0.027028
+ },
+ "ece": {
+ "mean": 0.012199,
+ "std": 0.004094,
+ "median": 0.012206,
+ "iqr": 0.004094,
+ "ci95_t": 0.01017
+ },
+ "num_seeds": 3
+ },
+ "G6": {
+ "val_selected_acc": {
+ "mean": 84.25,
+ "std": 0.219317,
+ "median": 84.2,
+ "iqr": 0.215,
+ "ci95_t": 0.54482
+ },
+ "val_selected_nll": {
+ "mean": 0.503809,
+ "std": 0.015789,
+ "median": 0.498121,
+ "iqr": 0.015,
+ "ci95_t": 0.039221
+ },
+ "brier": {
+ "mean": 0.231132,
+ "std": 0.004709,
+ "median": 0.230765,
+ "iqr": 0.004698,
+ "ci95_t": 0.011697
+ },
+ "ece": {
+ "mean": 0.019296,
+ "std": 0.007279,
+ "median": 0.023118,
+ "iqr": 0.006483,
+ "ci95_t": 0.018081
+ },
+ "num_seeds": 3
+ }
+ },
+ "root_cause_statuses": {
+ "regression_recovered": {
+ "status": "supported",
+ "recovered_configs": [
+ "G5",
+ "G6"
+ ],
+ "g8_mean_acc": 84.916667,
+ "g8_mean_nll": 0.48144,
+ "description": "Normalized geometry is within 1.0pp accuracy and 0.05 NLL of G8"
+ },
+ "anisotropic_per_tensor_scaling": {
+ "status": "rejected",
+ "test_config": "G1",
+ "ref_config": "G0",
+ "mean_nll_diff": 0.144072,
+ "mean_acc_diff": -2.5733,
+ "description": "global RMS scale versus per-tensor SD"
+ },
+ "nonzero_launch_velocity": {
+ "status": "unresolved",
+ "test_config": "G2",
+ "ref_config": "G0",
+ "description": "nonzero launch velocity versus zero"
+ },
+ "mutation": {
+ "status": "unresolved",
+ "test_config": "G3",
+ "ref_config": "G0",
+ "description": "mutation 0.02 versus none"
+ },
+ "velocity_mutation_interaction": {
+ "status": "unresolved",
+ "test_config": "G4",
+ "ref_config": "G2",
+ "description": "mutation given nonzero velocity"
+ },
+ "bound_expansion": {
+ "status": "unresolved",
+ "test_config": "G5",
+ "ref_config": "G4",
+ "description": "normalized bound 6 versus 3"
+ },
+ "broader_initialization": {
+ "status": "rejected",
+ "test_config": "G6",
+ "ref_config": "G5",
+ "mean_nll_diff": -0.006488,
+ "mean_acc_diff": 0.0133,
+ "description": "initial radius 1.5 versus 0.5"
+ },
+ "independent_initialization": {
+ "status": "unresolved",
+ "test_config": "G7",
+ "ref_config": "G2",
+ "description": "independent versus antithetic positions"
+ }
+ }
+ },
+ "resource_totals": {
+ "candidate_objective_queries": 421200,
+ "candidate_sample_evaluations": 842400000,
+ "validation_model_evaluations": 1826,
+ "summed_optimization_wall_time_sec": 596.998,
+ "summed_validation_wall_time_sec": 9.1062,
+ "official_test_evaluations": 0
+ }
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v6_phase_b_screen.json b/benchmark_results/pso_v6_phase_b_screen.json
new file mode 100644
index 0000000..bc1c38e
--- /dev/null
+++ b/benchmark_results/pso_v6_phase_b_screen.json
@@ -0,0 +1,12444 @@
+{
+ "protocol_version": "MNIST-PSO-RAW-V6 1.0.0",
+ "pso_version": "4.0.0",
+ "official_test_data_loaded": false,
+ "official_test_evaluations": 0,
+ "data_fingerprint": "26bd2ed5f27e7d24",
+ "base_model_seed": 41,
+ "base_model_fingerprint": "d0eee0ffd33088ed",
+ "geometry_configs": {
+ "G0": {
+ "config_id": "G0",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "exact V5 control"
+ },
+ "G1": {
+ "config_id": "G1",
+ "scale_type": "global_rms",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate anisotropic per-tensor scaling"
+ },
+ "G2": {
+ "config_id": "G2",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate nonzero launch velocity"
+ },
+ "G3": {
+ "config_id": "G3",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate mutation"
+ },
+ "G4": {
+ "config_id": "G4",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "velocity x mutation interaction"
+ },
+ "G5": {
+ "config_id": "G5",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test sufficient bound expansion"
+ },
+ "G6": {
+ "config_id": "G6",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 1.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test broader normalized initialization"
+ },
+ "G7": {
+ "config_id": "G7",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "independent",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate antithetic position coupling against G2"
+ },
+ "G8": {
+ "config_id": "G8",
+ "scale_type": "optimizer_default",
+ "init_position_mode": "independent",
+ "position_radius": 0.05,
+ "initial_velocity_radius": 0.05,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "retained semantic control (public Optimizer)"
+ }
+ },
+ "selection_rule": "lowest_validation_nll_then_highest_accuracy",
+ "provenance": {
+ "input_shape": [
+ 1,
+ 28,
+ 28
+ ],
+ "pca": false,
+ "raw_inputs": true,
+ "normalization_scope": "search_train_50000_only",
+ "train_mean": 0.130682,
+ "train_std": 0.308127,
+ "search_samples": 50000,
+ "val_samples": 10000,
+ "test_samples": 0,
+ "official_test_evaluations": 0,
+ "split_seed": 20260902,
+ "split_fingerprint": "51b289d9f503a9f3"
+ },
+ "hardware_provenance": {
+ "platform": "macOS-26.6.2-arm64-arm-64bit",
+ "system": "Darwin",
+ "machine": "arm64",
+ "processor": "arm",
+ "python_version": "3.11.15",
+ "torch_version": "2.13.0",
+ "pso_version": "4.0.0",
+ "device_type": "mps",
+ "device_str": "mps",
+ "mps_available": true
+ },
+ "timestamp": "2026-09-02 23:18:03",
+ "screen_payload": {
+ "phase": "screen",
+ "seed": 91,
+ "swarm_size": 30,
+ "epochs": 160,
+ "screen_results": {
+ "G0": {
+ "config_id": "G0",
+ "gbest_loss": 1.147565,
+ "gbest_acc": 69.8,
+ "gbest_val_loss": 1.183117,
+ "gbest_val_acc": 67.73,
+ "val_selected_particle_idx": 8,
+ "val_selected_loss": 1.183117,
+ "val_selected_acc": 67.73,
+ "val_metrics": {
+ "accuracy": 67.73,
+ "nll": 1.183117,
+ "brier": 0.53537,
+ "ece": 0.247347,
+ "margin": 0.248949
+ },
+ "wall_time_sec": 8.4356,
+ "optimization_wall_time_sec": 8.2302,
+ "validation_wall_time_sec": 0.2054,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160
+ ],
+ "pbest_update_counts": 2436,
+ "boundary_hits": 279090,
+ "boundary_occupancy": 0.006391,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.187343,
+ "position_radius": 12.190442,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.319009,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.310269,
+ "gbest_acc": 7.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.302216,
+ "gbest_acc": 9.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.280997,
+ "gbest_acc": 12.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.248806,
+ "gbest_acc": 20.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.22007,
+ "gbest_acc": 24.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.197811,
+ "gbest_acc": 22.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.181172,
+ "gbest_acc": 21.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.14378,
+ "gbest_acc": 19.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.111105,
+ "gbest_acc": 19.3,
+ "val_loss": 2.113562,
+ "val_acc": 20.15
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.065237,
+ "gbest_acc": 21.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.022572,
+ "gbest_acc": 26.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.99992,
+ "gbest_acc": 27.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.970806,
+ "gbest_acc": 30.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.964259,
+ "gbest_acc": 29.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.936239,
+ "gbest_acc": 33.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.932432,
+ "gbest_acc": 33.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.908575,
+ "gbest_acc": 34.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.900177,
+ "gbest_acc": 34.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.893059,
+ "gbest_acc": 35.15,
+ "val_loss": 1.908893,
+ "val_acc": 35.05
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.893059,
+ "gbest_acc": 35.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.889398,
+ "gbest_acc": 35.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.879795,
+ "gbest_acc": 38.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.859706,
+ "gbest_acc": 38.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.844069,
+ "gbest_acc": 37.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.843418,
+ "gbest_acc": 38.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.835918,
+ "gbest_acc": 36.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.825405,
+ "gbest_acc": 37.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.793166,
+ "gbest_acc": 41.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.793166,
+ "gbest_acc": 41.3,
+ "val_loss": 1.813975,
+ "val_acc": 39.9
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.793166,
+ "gbest_acc": 41.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.793166,
+ "gbest_acc": 41.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.783466,
+ "gbest_acc": 41.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.770267,
+ "gbest_acc": 43.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.766128,
+ "gbest_acc": 43.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74411,
+ "gbest_acc": 43.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74411,
+ "gbest_acc": 43.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.722016,
+ "gbest_acc": 45.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.715608,
+ "gbest_acc": 44.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.694592,
+ "gbest_acc": 47.3,
+ "val_loss": 1.7177,
+ "val_acc": 45.68
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687191,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.679955,
+ "gbest_acc": 48.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.665032,
+ "gbest_acc": 47.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.660036,
+ "gbest_acc": 48.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.660036,
+ "gbest_acc": 48.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.656864,
+ "gbest_acc": 50.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.648261,
+ "gbest_acc": 50.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.637429,
+ "gbest_acc": 53.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629559,
+ "gbest_acc": 50.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.627745,
+ "gbest_acc": 49.4,
+ "val_loss": 1.652814,
+ "val_acc": 46.97
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624722,
+ "gbest_acc": 51.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.624722,
+ "gbest_acc": 51.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.621271,
+ "gbest_acc": 49.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.603937,
+ "gbest_acc": 51.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.603892,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.574743,
+ "gbest_acc": 54.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566305,
+ "gbest_acc": 56.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566305,
+ "gbest_acc": 56.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.566305,
+ "gbest_acc": 56.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.561212,
+ "gbest_acc": 56.3,
+ "val_loss": 1.58474,
+ "val_acc": 53.4
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.550911,
+ "gbest_acc": 54.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.550176,
+ "gbest_acc": 55.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.54394,
+ "gbest_acc": 56.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.538204,
+ "gbest_acc": 55.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.536207,
+ "gbest_acc": 56.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.516027,
+ "gbest_acc": 57.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.514509,
+ "gbest_acc": 56.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.501886,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.501886,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.498765,
+ "gbest_acc": 57.05,
+ "val_loss": 1.530252,
+ "val_acc": 55.27
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.498765,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.494819,
+ "gbest_acc": 58.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.486218,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.486218,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.486218,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.47865,
+ "gbest_acc": 58.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.471761,
+ "gbest_acc": 59.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.470706,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.455133,
+ "gbest_acc": 61.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.447378,
+ "gbest_acc": 62.2,
+ "val_loss": 1.478323,
+ "val_acc": 59.59
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.446284,
+ "gbest_acc": 61.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.444786,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.444786,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.444786,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.426749,
+ "gbest_acc": 63.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.425618,
+ "gbest_acc": 60.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.420136,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.420136,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.414905,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.40597,
+ "gbest_acc": 61.0,
+ "val_loss": 1.439038,
+ "val_acc": 58.65
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.40361,
+ "gbest_acc": 61.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.395106,
+ "gbest_acc": 61.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.395106,
+ "gbest_acc": 61.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.394371,
+ "gbest_acc": 61.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.390707,
+ "gbest_acc": 64.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.38849,
+ "gbest_acc": 62.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.38849,
+ "gbest_acc": 62.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.38849,
+ "gbest_acc": 62.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388122,
+ "gbest_acc": 62.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388122,
+ "gbest_acc": 62.0,
+ "val_loss": 1.419643,
+ "val_acc": 59.72
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388122,
+ "gbest_acc": 62.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.375218,
+ "gbest_acc": 63.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.373271,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362747,
+ "gbest_acc": 64.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362747,
+ "gbest_acc": 64.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.359635,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348393,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348393,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348393,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348393,
+ "gbest_acc": 64.45,
+ "val_loss": 1.38298,
+ "val_acc": 62.02
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.33786,
+ "gbest_acc": 66.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.33786,
+ "gbest_acc": 66.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.333928,
+ "gbest_acc": 66.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.328514,
+ "gbest_acc": 65.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.328241,
+ "gbest_acc": 65.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.321243,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.316853,
+ "gbest_acc": 66.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.314892,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.312831,
+ "gbest_acc": 65.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.312831,
+ "gbest_acc": 65.1,
+ "val_loss": 1.349793,
+ "val_acc": 62.28
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.305485,
+ "gbest_acc": 66.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.299608,
+ "gbest_acc": 66.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.293387,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.293387,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.289006,
+ "gbest_acc": 66.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279774,
+ "gbest_acc": 66.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.273683,
+ "gbest_acc": 67.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.273683,
+ "gbest_acc": 67.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.270333,
+ "gbest_acc": 67.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.270079,
+ "gbest_acc": 66.55,
+ "val_loss": 1.299638,
+ "val_acc": 64.95
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.262235,
+ "gbest_acc": 67.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.256521,
+ "gbest_acc": 67.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240951,
+ "gbest_acc": 67.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240951,
+ "gbest_acc": 67.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240951,
+ "gbest_acc": 67.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.240951,
+ "gbest_acc": 67.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.23886,
+ "gbest_acc": 68.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.235466,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.223605,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.218237,
+ "gbest_acc": 68.85,
+ "val_loss": 1.255444,
+ "val_acc": 66.78
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.216309,
+ "gbest_acc": 67.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.214696,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.209994,
+ "gbest_acc": 68.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.206406,
+ "gbest_acc": 67.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.206406,
+ "gbest_acc": 67.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.204739,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.201082,
+ "gbest_acc": 68.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.195486,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.195272,
+ "gbest_acc": 68.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.190521,
+ "gbest_acc": 69.0,
+ "val_loss": 1.233496,
+ "val_acc": 66.27
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.167662,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.167662,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.167662,
+ "gbest_acc": 69.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.155561,
+ "gbest_acc": 69.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.155403,
+ "gbest_acc": 69.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.150636,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.150636,
+ "gbest_acc": 69.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.149532,
+ "gbest_acc": 70.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.148374,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.147565,
+ "gbest_acc": 69.8,
+ "val_loss": 1.183117,
+ "val_acc": 67.73
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G0",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "exact V5 control"
+ }
+ },
+ "G1": {
+ "config_id": "G1",
+ "gbest_loss": 1.424766,
+ "gbest_acc": 64.65,
+ "gbest_val_loss": 1.439619,
+ "gbest_val_acc": 62.89,
+ "val_selected_particle_idx": 15,
+ "val_selected_loss": 1.437604,
+ "val_selected_acc": 62.32,
+ "val_metrics": {
+ "accuracy": 62.32,
+ "nll": 1.437604,
+ "brier": 0.638084,
+ "ece": 0.309309,
+ "margin": 0.143863
+ },
+ "wall_time_sec": 6.6136,
+ "optimization_wall_time_sec": 6.4264,
+ "validation_wall_time_sec": 0.1871,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160
+ ],
+ "pbest_update_counts": 2515,
+ "boundary_hits": 347542,
+ "boundary_occupancy": 0.007958,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.171411,
+ "position_radius": 12.100932,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.315947,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.308322,
+ "gbest_acc": 10.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.294986,
+ "gbest_acc": 10.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.273571,
+ "gbest_acc": 12.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.253161,
+ "gbest_acc": 12.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.222763,
+ "gbest_acc": 16.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.192668,
+ "gbest_acc": 19.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.173146,
+ "gbest_acc": 22.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.150064,
+ "gbest_acc": 28.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.136011,
+ "gbest_acc": 29.85,
+ "val_loss": 2.14699,
+ "val_acc": 26.68
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.12312,
+ "gbest_acc": 29.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.114006,
+ "gbest_acc": 32.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.095677,
+ "gbest_acc": 29.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.085551,
+ "gbest_acc": 31.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.068933,
+ "gbest_acc": 31.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.052427,
+ "gbest_acc": 31.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.043275,
+ "gbest_acc": 32.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.034469,
+ "gbest_acc": 30.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.027554,
+ "gbest_acc": 32.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.021309,
+ "gbest_acc": 28.8,
+ "val_loss": 2.033511,
+ "val_acc": 27.52
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.009541,
+ "gbest_acc": 30.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.005577,
+ "gbest_acc": 33.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.997396,
+ "gbest_acc": 37.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.988852,
+ "gbest_acc": 35.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.967112,
+ "gbest_acc": 37.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.955614,
+ "gbest_acc": 37.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.954019,
+ "gbest_acc": 37.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.954019,
+ "gbest_acc": 37.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.952413,
+ "gbest_acc": 36.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.929805,
+ "gbest_acc": 43.45,
+ "val_loss": 1.9382,
+ "val_acc": 42.12
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.929805,
+ "gbest_acc": 43.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.929805,
+ "gbest_acc": 43.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.929805,
+ "gbest_acc": 43.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.92051,
+ "gbest_acc": 42.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.904802,
+ "gbest_acc": 43.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.881655,
+ "gbest_acc": 47.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.866855,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.862242,
+ "gbest_acc": 45.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.862242,
+ "gbest_acc": 45.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.862242,
+ "gbest_acc": 45.05,
+ "val_loss": 1.870654,
+ "val_acc": 44.47
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.848211,
+ "gbest_acc": 46.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.830021,
+ "gbest_acc": 49.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.824273,
+ "gbest_acc": 47.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.821906,
+ "gbest_acc": 49.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.821078,
+ "gbest_acc": 49.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.821078,
+ "gbest_acc": 49.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.818256,
+ "gbest_acc": 49.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.806508,
+ "gbest_acc": 49.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.806508,
+ "gbest_acc": 49.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.806508,
+ "gbest_acc": 49.7,
+ "val_loss": 1.812953,
+ "val_acc": 47.06
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.801929,
+ "gbest_acc": 50.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.791898,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.791898,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.791898,
+ "gbest_acc": 51.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.790438,
+ "gbest_acc": 52.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.784344,
+ "gbest_acc": 53.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.782505,
+ "gbest_acc": 50.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.780576,
+ "gbest_acc": 50.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.772899,
+ "gbest_acc": 49.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.754965,
+ "gbest_acc": 51.05,
+ "val_loss": 1.766327,
+ "val_acc": 48.98
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.747439,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.747439,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.743661,
+ "gbest_acc": 52.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.740029,
+ "gbest_acc": 52.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.73525,
+ "gbest_acc": 54.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.731287,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.727312,
+ "gbest_acc": 54.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.72605,
+ "gbest_acc": 55.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.72605,
+ "gbest_acc": 55.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.717518,
+ "gbest_acc": 55.85,
+ "val_loss": 1.727644,
+ "val_acc": 54.48
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.717518,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.714798,
+ "gbest_acc": 54.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.714798,
+ "gbest_acc": 54.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711542,
+ "gbest_acc": 53.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.708385,
+ "gbest_acc": 56.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.708385,
+ "gbest_acc": 56.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.705886,
+ "gbest_acc": 55.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.694518,
+ "gbest_acc": 56.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.694518,
+ "gbest_acc": 56.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.691288,
+ "gbest_acc": 55.95,
+ "val_loss": 1.698494,
+ "val_acc": 54.14
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.685534,
+ "gbest_acc": 55.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675454,
+ "gbest_acc": 54.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.670128,
+ "gbest_acc": 55.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.661029,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.661029,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.660406,
+ "gbest_acc": 56.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.660406,
+ "gbest_acc": 56.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.649995,
+ "gbest_acc": 57.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.648547,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.6459,
+ "gbest_acc": 55.5,
+ "val_loss": 1.655206,
+ "val_acc": 54.85
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.641742,
+ "gbest_acc": 58.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629151,
+ "gbest_acc": 57.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629151,
+ "gbest_acc": 57.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.623244,
+ "gbest_acc": 55.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.617541,
+ "gbest_acc": 57.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.615795,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.610377,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.610377,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.606006,
+ "gbest_acc": 56.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.593474,
+ "gbest_acc": 57.85,
+ "val_loss": 1.603899,
+ "val_acc": 57.46
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.593474,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.584104,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.584104,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.584104,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.583131,
+ "gbest_acc": 58.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.577354,
+ "gbest_acc": 57.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.575562,
+ "gbest_acc": 58.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.570815,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.570815,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.569771,
+ "gbest_acc": 58.7,
+ "val_loss": 1.57983,
+ "val_acc": 57.85
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.556539,
+ "gbest_acc": 58.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.556348,
+ "gbest_acc": 59.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.549969,
+ "gbest_acc": 57.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.549892,
+ "gbest_acc": 57.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.53986,
+ "gbest_acc": 59.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.535266,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.535266,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.535266,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.535266,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.530102,
+ "gbest_acc": 60.45,
+ "val_loss": 1.541431,
+ "val_acc": 58.95
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.529386,
+ "gbest_acc": 60.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.528412,
+ "gbest_acc": 59.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52669,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52669,
+ "gbest_acc": 60.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.519616,
+ "gbest_acc": 62.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.515662,
+ "gbest_acc": 61.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.515231,
+ "gbest_acc": 60.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.510802,
+ "gbest_acc": 59.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.509791,
+ "gbest_acc": 61.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.506625,
+ "gbest_acc": 61.1,
+ "val_loss": 1.516113,
+ "val_acc": 59.4
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.500361,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.500361,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.494626,
+ "gbest_acc": 61.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.494626,
+ "gbest_acc": 61.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.487294,
+ "gbest_acc": 62.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.485371,
+ "gbest_acc": 62.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.485371,
+ "gbest_acc": 62.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.485371,
+ "gbest_acc": 62.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.47923,
+ "gbest_acc": 62.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.476306,
+ "gbest_acc": 62.8,
+ "val_loss": 1.487363,
+ "val_acc": 61.41
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.476306,
+ "gbest_acc": 62.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474686,
+ "gbest_acc": 61.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.469395,
+ "gbest_acc": 62.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.468387,
+ "gbest_acc": 63.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.461817,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.461817,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.461817,
+ "gbest_acc": 64.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.456501,
+ "gbest_acc": 64.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452649,
+ "gbest_acc": 63.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452649,
+ "gbest_acc": 63.15,
+ "val_loss": 1.46415,
+ "val_acc": 61.72
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.450157,
+ "gbest_acc": 63.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.445838,
+ "gbest_acc": 64.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.440069,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.435774,
+ "gbest_acc": 65.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.433747,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.431516,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.431516,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.431516,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.429243,
+ "gbest_acc": 64.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.424766,
+ "gbest_acc": 64.65,
+ "val_loss": 1.439619,
+ "val_acc": 62.89
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G1",
+ "scale_type": "global_rms",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate anisotropic per-tensor scaling"
+ }
+ },
+ "G2": {
+ "config_id": "G2",
+ "gbest_loss": 1.260671,
+ "gbest_acc": 63.2,
+ "gbest_val_loss": 1.298475,
+ "gbest_val_acc": 60.76,
+ "val_selected_particle_idx": 11,
+ "val_selected_loss": 1.296105,
+ "val_selected_acc": 60.72,
+ "val_metrics": {
+ "accuracy": 60.72,
+ "nll": 1.296105,
+ "brier": 0.585207,
+ "ece": 0.186668,
+ "margin": 0.235434
+ },
+ "wall_time_sec": 6.6528,
+ "optimization_wall_time_sec": 6.4626,
+ "validation_wall_time_sec": 0.1902,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160
+ ],
+ "pbest_update_counts": 2335,
+ "boundary_hits": 217768,
+ "boundary_occupancy": 0.004987,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.127313,
+ "position_radius": 8.553208,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.319009,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.303509,
+ "gbest_acc": 9.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.296052,
+ "gbest_acc": 9.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.262821,
+ "gbest_acc": 10.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.247507,
+ "gbest_acc": 12.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.222965,
+ "gbest_acc": 14.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.19646,
+ "gbest_acc": 16.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.14694,
+ "gbest_acc": 17.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.119284,
+ "gbest_acc": 20.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.077625,
+ "gbest_acc": 20.8,
+ "val_loss": 2.075401,
+ "val_acc": 21.73
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.048708,
+ "gbest_acc": 23.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.042735,
+ "gbest_acc": 28.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.042735,
+ "gbest_acc": 28.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.037079,
+ "gbest_acc": 33.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.030461,
+ "gbest_acc": 27.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.029878,
+ "gbest_acc": 29.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.012703,
+ "gbest_acc": 31.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.012703,
+ "gbest_acc": 31.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.004503,
+ "gbest_acc": 33.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.997764,
+ "gbest_acc": 32.8,
+ "val_loss": 2.006228,
+ "val_acc": 32.64
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.953959,
+ "gbest_acc": 35.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.953959,
+ "gbest_acc": 35.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.951544,
+ "gbest_acc": 30.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.913776,
+ "gbest_acc": 34.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.913776,
+ "gbest_acc": 34.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.913776,
+ "gbest_acc": 34.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.908982,
+ "gbest_acc": 33.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.908982,
+ "gbest_acc": 33.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.907122,
+ "gbest_acc": 33.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.901545,
+ "gbest_acc": 34.1,
+ "val_loss": 1.897862,
+ "val_acc": 34.22
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.850567,
+ "gbest_acc": 38.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.850567,
+ "gbest_acc": 38.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.850567,
+ "gbest_acc": 38.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.840613,
+ "gbest_acc": 38.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.840501,
+ "gbest_acc": 36.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.823124,
+ "gbest_acc": 40.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.823124,
+ "gbest_acc": 40.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.800574,
+ "gbest_acc": 39.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.787842,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.78207,
+ "gbest_acc": 40.8,
+ "val_loss": 1.789581,
+ "val_acc": 39.88
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.764248,
+ "gbest_acc": 42.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.764248,
+ "gbest_acc": 42.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.764248,
+ "gbest_acc": 42.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.750987,
+ "gbest_acc": 45.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.750987,
+ "gbest_acc": 45.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.742348,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.742348,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74108,
+ "gbest_acc": 46.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730096,
+ "gbest_acc": 46.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730096,
+ "gbest_acc": 46.25,
+ "val_loss": 1.744376,
+ "val_acc": 45.5
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730096,
+ "gbest_acc": 46.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730096,
+ "gbest_acc": 46.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.72351,
+ "gbest_acc": 43.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.707215,
+ "gbest_acc": 46.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.705108,
+ "gbest_acc": 48.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.698384,
+ "gbest_acc": 45.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687789,
+ "gbest_acc": 46.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687789,
+ "gbest_acc": 46.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.683239,
+ "gbest_acc": 46.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.677621,
+ "gbest_acc": 47.0,
+ "val_loss": 1.691962,
+ "val_acc": 46.35
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.67126,
+ "gbest_acc": 45.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.67126,
+ "gbest_acc": 45.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.67126,
+ "gbest_acc": 45.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.668337,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.659695,
+ "gbest_acc": 46.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.659695,
+ "gbest_acc": 46.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.657354,
+ "gbest_acc": 47.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.657354,
+ "gbest_acc": 47.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.657354,
+ "gbest_acc": 47.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.650023,
+ "gbest_acc": 48.3,
+ "val_loss": 1.662783,
+ "val_acc": 48.16
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.650023,
+ "gbest_acc": 48.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.650023,
+ "gbest_acc": 48.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.640128,
+ "gbest_acc": 47.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.628654,
+ "gbest_acc": 48.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.618027,
+ "gbest_acc": 51.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.61674,
+ "gbest_acc": 50.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.61674,
+ "gbest_acc": 50.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.600559,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.598821,
+ "gbest_acc": 50.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585512,
+ "gbest_acc": 50.05,
+ "val_loss": 1.603782,
+ "val_acc": 50.01
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585512,
+ "gbest_acc": 50.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.585512,
+ "gbest_acc": 50.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.565692,
+ "gbest_acc": 50.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.545885,
+ "gbest_acc": 52.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.543613,
+ "gbest_acc": 52.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.543613,
+ "gbest_acc": 52.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.543613,
+ "gbest_acc": 52.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.535578,
+ "gbest_acc": 52.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.529132,
+ "gbest_acc": 55.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.524492,
+ "gbest_acc": 52.8,
+ "val_loss": 1.551724,
+ "val_acc": 51.83
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.524492,
+ "gbest_acc": 52.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.524492,
+ "gbest_acc": 52.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.524492,
+ "gbest_acc": 52.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.518399,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.518399,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.518399,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497453,
+ "gbest_acc": 55.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497453,
+ "gbest_acc": 55.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497453,
+ "gbest_acc": 55.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.491416,
+ "gbest_acc": 53.85,
+ "val_loss": 1.521564,
+ "val_acc": 51.36
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474938,
+ "gbest_acc": 55.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474938,
+ "gbest_acc": 55.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460145,
+ "gbest_acc": 54.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460145,
+ "gbest_acc": 54.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.453022,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.446806,
+ "gbest_acc": 54.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.434058,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.427915,
+ "gbest_acc": 55.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.426081,
+ "gbest_acc": 55.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.422212,
+ "gbest_acc": 55.75,
+ "val_loss": 1.461187,
+ "val_acc": 53.99
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.421268,
+ "gbest_acc": 55.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.413391,
+ "gbest_acc": 55.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.408327,
+ "gbest_acc": 55.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.404039,
+ "gbest_acc": 56.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401398,
+ "gbest_acc": 57.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401398,
+ "gbest_acc": 57.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.401398,
+ "gbest_acc": 57.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.397829,
+ "gbest_acc": 57.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.392224,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.392224,
+ "gbest_acc": 57.05,
+ "val_loss": 1.429698,
+ "val_acc": 54.84
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.387502,
+ "gbest_acc": 57.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.384152,
+ "gbest_acc": 57.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.37996,
+ "gbest_acc": 56.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.376825,
+ "gbest_acc": 56.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.374364,
+ "gbest_acc": 56.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.37091,
+ "gbest_acc": 57.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.369904,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.361282,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357682,
+ "gbest_acc": 58.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.356437,
+ "gbest_acc": 59.2,
+ "val_loss": 1.392462,
+ "val_acc": 56.2
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.353375,
+ "gbest_acc": 58.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.352903,
+ "gbest_acc": 57.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.344424,
+ "gbest_acc": 58.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.340071,
+ "gbest_acc": 58.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338086,
+ "gbest_acc": 58.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.334613,
+ "gbest_acc": 58.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332369,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332369,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331179,
+ "gbest_acc": 58.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.324061,
+ "gbest_acc": 59.3,
+ "val_loss": 1.360066,
+ "val_acc": 57.89
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.313231,
+ "gbest_acc": 59.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.313231,
+ "gbest_acc": 59.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.308882,
+ "gbest_acc": 59.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.305071,
+ "gbest_acc": 60.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.305071,
+ "gbest_acc": 60.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.297366,
+ "gbest_acc": 60.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.295663,
+ "gbest_acc": 60.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.294579,
+ "gbest_acc": 61.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.28834,
+ "gbest_acc": 61.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.286525,
+ "gbest_acc": 61.8,
+ "val_loss": 1.323947,
+ "val_acc": 59.65
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.286525,
+ "gbest_acc": 61.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.284404,
+ "gbest_acc": 62.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.279623,
+ "gbest_acc": 62.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.274098,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.272405,
+ "gbest_acc": 62.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.270274,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.270274,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.267652,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.263967,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.260671,
+ "gbest_acc": 63.2,
+ "val_loss": 1.298475,
+ "val_acc": 60.76
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G2",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate nonzero launch velocity"
+ }
+ },
+ "G3": {
+ "config_id": "G3",
+ "gbest_loss": 1.101833,
+ "gbest_acc": 70.5,
+ "gbest_val_loss": 1.130839,
+ "gbest_val_acc": 68.07,
+ "val_selected_particle_idx": 22,
+ "val_selected_loss": 1.130839,
+ "val_selected_acc": 68.07,
+ "val_metrics": {
+ "accuracy": 68.07,
+ "nll": 1.130839,
+ "brier": 0.513959,
+ "ece": 0.226902,
+ "margin": 0.271513
+ },
+ "wall_time_sec": 6.4943,
+ "optimization_wall_time_sec": 6.3127,
+ "validation_wall_time_sec": 0.1817,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 88,
+ "final_moment_steps": [
+ 31,
+ 46,
+ 47,
+ 118,
+ 13,
+ 16,
+ 41,
+ 42,
+ 41,
+ 76,
+ 160,
+ 28,
+ 3,
+ 11,
+ 43,
+ 59,
+ 14,
+ 56,
+ 8,
+ 107,
+ 4,
+ 36,
+ 17,
+ 41,
+ 34,
+ 17,
+ 31,
+ 88,
+ 4,
+ 83
+ ],
+ "pbest_update_counts": 2576,
+ "boundary_hits": 273258,
+ "boundary_occupancy": 0.006257,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.161481,
+ "position_radius": 11.811624,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.319009,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.310269,
+ "gbest_acc": 7.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.302216,
+ "gbest_acc": 9.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.280997,
+ "gbest_acc": 12.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.248806,
+ "gbest_acc": 20.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.22007,
+ "gbest_acc": 24.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.197811,
+ "gbest_acc": 22.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.181172,
+ "gbest_acc": 21.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.159871,
+ "gbest_acc": 20.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.136736,
+ "gbest_acc": 21.3,
+ "val_loss": 2.134861,
+ "val_acc": 22.43
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.114397,
+ "gbest_acc": 25.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.084893,
+ "gbest_acc": 28.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.061571,
+ "gbest_acc": 29.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.032724,
+ "gbest_acc": 34.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.013328,
+ "gbest_acc": 33.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.993989,
+ "gbest_acc": 32.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.979469,
+ "gbest_acc": 33.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.979469,
+ "gbest_acc": 33.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.979469,
+ "gbest_acc": 33.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.97274,
+ "gbest_acc": 34.7,
+ "val_loss": 1.983832,
+ "val_acc": 34.16
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.967456,
+ "gbest_acc": 34.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.964252,
+ "gbest_acc": 35.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.964252,
+ "gbest_acc": 35.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.962797,
+ "gbest_acc": 35.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.953577,
+ "gbest_acc": 37.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.948298,
+ "gbest_acc": 37.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.940264,
+ "gbest_acc": 40.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.920149,
+ "gbest_acc": 40.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.919143,
+ "gbest_acc": 40.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.914726,
+ "gbest_acc": 39.2,
+ "val_loss": 1.925831,
+ "val_acc": 39.53
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.904199,
+ "gbest_acc": 40.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.887915,
+ "gbest_acc": 40.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.862978,
+ "gbest_acc": 39.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.855988,
+ "gbest_acc": 41.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.855988,
+ "gbest_acc": 41.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.855988,
+ "gbest_acc": 41.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.855988,
+ "gbest_acc": 41.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.848551,
+ "gbest_acc": 39.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.846189,
+ "gbest_acc": 40.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.820285,
+ "gbest_acc": 40.65,
+ "val_loss": 1.835167,
+ "val_acc": 38.95
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.808691,
+ "gbest_acc": 41.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.808691,
+ "gbest_acc": 41.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.800475,
+ "gbest_acc": 41.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.780675,
+ "gbest_acc": 41.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.772191,
+ "gbest_acc": 43.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.759504,
+ "gbest_acc": 40.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.744899,
+ "gbest_acc": 44.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711915,
+ "gbest_acc": 45.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.709915,
+ "gbest_acc": 43.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.694066,
+ "gbest_acc": 45.65,
+ "val_loss": 1.713861,
+ "val_acc": 44.24
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.693825,
+ "gbest_acc": 48.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.686315,
+ "gbest_acc": 48.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.667942,
+ "gbest_acc": 48.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.664553,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.664553,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.654114,
+ "gbest_acc": 50.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.639485,
+ "gbest_acc": 47.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629218,
+ "gbest_acc": 46.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.625734,
+ "gbest_acc": 45.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.612302,
+ "gbest_acc": 49.45,
+ "val_loss": 1.628001,
+ "val_acc": 49.78
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.606189,
+ "gbest_acc": 51.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.605763,
+ "gbest_acc": 49.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.582973,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.582973,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.571994,
+ "gbest_acc": 51.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.571994,
+ "gbest_acc": 51.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.563389,
+ "gbest_acc": 52.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.543682,
+ "gbest_acc": 55.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.523503,
+ "gbest_acc": 55.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52179,
+ "gbest_acc": 54.75,
+ "val_loss": 1.537683,
+ "val_acc": 54.22
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52179,
+ "gbest_acc": 54.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.520642,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.50233,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497037,
+ "gbest_acc": 55.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497037,
+ "gbest_acc": 55.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.497037,
+ "gbest_acc": 55.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.495274,
+ "gbest_acc": 55.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.492267,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.484278,
+ "gbest_acc": 56.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.468022,
+ "gbest_acc": 57.25,
+ "val_loss": 1.490051,
+ "val_acc": 55.55
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.464147,
+ "gbest_acc": 57.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.460034,
+ "gbest_acc": 57.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.444612,
+ "gbest_acc": 57.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.444612,
+ "gbest_acc": 57.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.441682,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.430969,
+ "gbest_acc": 57.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.430969,
+ "gbest_acc": 57.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.414128,
+ "gbest_acc": 58.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.414128,
+ "gbest_acc": 58.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.407198,
+ "gbest_acc": 58.15,
+ "val_loss": 1.433016,
+ "val_acc": 57.1
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.384158,
+ "gbest_acc": 59.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.382746,
+ "gbest_acc": 60.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.367198,
+ "gbest_acc": 60.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.364888,
+ "gbest_acc": 60.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.359646,
+ "gbest_acc": 59.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.358774,
+ "gbest_acc": 59.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.353043,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.347814,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.342674,
+ "gbest_acc": 60.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.330429,
+ "gbest_acc": 61.0,
+ "val_loss": 1.34453,
+ "val_acc": 60.52
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.328923,
+ "gbest_acc": 60.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.32153,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.320176,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.304767,
+ "gbest_acc": 62.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.304732,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.304732,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.304732,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.303363,
+ "gbest_acc": 61.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282837,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282837,
+ "gbest_acc": 63.3,
+ "val_loss": 1.298784,
+ "val_acc": 60.86
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282837,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.280779,
+ "gbest_acc": 62.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.280779,
+ "gbest_acc": 62.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.271439,
+ "gbest_acc": 63.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26861,
+ "gbest_acc": 64.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.263372,
+ "gbest_acc": 63.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.263372,
+ "gbest_acc": 63.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.259126,
+ "gbest_acc": 64.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.254396,
+ "gbest_acc": 64.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.245999,
+ "gbest_acc": 64.35,
+ "val_loss": 1.26705,
+ "val_acc": 62.56
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.235562,
+ "gbest_acc": 65.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.235562,
+ "gbest_acc": 65.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.22955,
+ "gbest_acc": 64.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.221117,
+ "gbest_acc": 65.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.221117,
+ "gbest_acc": 65.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.220666,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.209499,
+ "gbest_acc": 65.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.204967,
+ "gbest_acc": 65.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.204547,
+ "gbest_acc": 63.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.193624,
+ "gbest_acc": 64.25,
+ "val_loss": 1.209377,
+ "val_acc": 63.59
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.180667,
+ "gbest_acc": 65.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.168593,
+ "gbest_acc": 65.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.162642,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.162642,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.162642,
+ "gbest_acc": 67.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.159592,
+ "gbest_acc": 68.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.148466,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.148466,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.147935,
+ "gbest_acc": 68.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146317,
+ "gbest_acc": 67.35,
+ "val_loss": 1.16723,
+ "val_acc": 66.6
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.144767,
+ "gbest_acc": 67.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.144767,
+ "gbest_acc": 67.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.134513,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.134513,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.134513,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132542,
+ "gbest_acc": 68.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132542,
+ "gbest_acc": 68.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.128464,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12701,
+ "gbest_acc": 69.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12701,
+ "gbest_acc": 69.15,
+ "val_loss": 1.152151,
+ "val_acc": 67.67
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12701,
+ "gbest_acc": 69.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.12701,
+ "gbest_acc": 69.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.120452,
+ "gbest_acc": 68.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.116909,
+ "gbest_acc": 68.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.109736,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.107309,
+ "gbest_acc": 68.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106793,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.106793,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.103275,
+ "gbest_acc": 69.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.101833,
+ "gbest_acc": 70.5,
+ "val_loss": 1.130839,
+ "val_acc": 68.07
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G3",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.0,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate mutation"
+ }
+ },
+ "G4": {
+ "config_id": "G4",
+ "gbest_loss": 1.06531,
+ "gbest_acc": 67.7,
+ "gbest_val_loss": 1.11628,
+ "gbest_val_acc": 65.76,
+ "val_selected_particle_idx": 18,
+ "val_selected_loss": 1.11628,
+ "val_selected_acc": 65.76,
+ "val_metrics": {
+ "accuracy": 65.76,
+ "nll": 1.11628,
+ "brier": 0.514631,
+ "ece": 0.174604,
+ "margin": 0.291075
+ },
+ "wall_time_sec": 6.4837,
+ "optimization_wall_time_sec": 6.3022,
+ "validation_wall_time_sec": 0.1815,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 88,
+ "final_moment_steps": [
+ 31,
+ 46,
+ 47,
+ 118,
+ 13,
+ 16,
+ 41,
+ 42,
+ 41,
+ 76,
+ 160,
+ 28,
+ 3,
+ 11,
+ 43,
+ 59,
+ 14,
+ 56,
+ 8,
+ 107,
+ 4,
+ 36,
+ 17,
+ 41,
+ 34,
+ 17,
+ 31,
+ 88,
+ 4,
+ 83
+ ],
+ "pbest_update_counts": 2125,
+ "boundary_hits": 317925,
+ "boundary_occupancy": 0.00728,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.136519,
+ "position_radius": 10.236586,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.319009,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.303509,
+ "gbest_acc": 9.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.296052,
+ "gbest_acc": 9.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.262821,
+ "gbest_acc": 10.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.247507,
+ "gbest_acc": 12.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.222965,
+ "gbest_acc": 14.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.19646,
+ "gbest_acc": 16.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.14694,
+ "gbest_acc": 17.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.119284,
+ "gbest_acc": 20.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.077625,
+ "gbest_acc": 20.8,
+ "val_loss": 2.075401,
+ "val_acc": 21.73
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.048708,
+ "gbest_acc": 23.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.042735,
+ "gbest_acc": 28.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.042735,
+ "gbest_acc": 28.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.037079,
+ "gbest_acc": 33.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.037079,
+ "gbest_acc": 33.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.034766,
+ "gbest_acc": 32.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.031814,
+ "gbest_acc": 33.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.012494,
+ "gbest_acc": 32.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.003936,
+ "gbest_acc": 36.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.985062,
+ "gbest_acc": 36.35,
+ "val_loss": 1.990384,
+ "val_acc": 37.17
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.977002,
+ "gbest_acc": 33.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.950469,
+ "gbest_acc": 34.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.9143,
+ "gbest_acc": 36.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.9143,
+ "gbest_acc": 36.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.90773,
+ "gbest_acc": 36.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.90773,
+ "gbest_acc": 36.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883531,
+ "gbest_acc": 35.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883531,
+ "gbest_acc": 35.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.878594,
+ "gbest_acc": 36.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.847759,
+ "gbest_acc": 39.4,
+ "val_loss": 1.880379,
+ "val_acc": 37.86
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.847759,
+ "gbest_acc": 39.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.835037,
+ "gbest_acc": 41.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.820522,
+ "gbest_acc": 41.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.817504,
+ "gbest_acc": 40.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.806495,
+ "gbest_acc": 39.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.795688,
+ "gbest_acc": 39.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.783437,
+ "gbest_acc": 41.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.783437,
+ "gbest_acc": 41.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.783437,
+ "gbest_acc": 41.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.780061,
+ "gbest_acc": 40.4,
+ "val_loss": 1.816181,
+ "val_acc": 40.71
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.7647,
+ "gbest_acc": 40.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.755221,
+ "gbest_acc": 42.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.755221,
+ "gbest_acc": 42.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74276,
+ "gbest_acc": 40.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.74276,
+ "gbest_acc": 40.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.716747,
+ "gbest_acc": 42.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.716747,
+ "gbest_acc": 42.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.716747,
+ "gbest_acc": 42.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.703336,
+ "gbest_acc": 43.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.681799,
+ "gbest_acc": 44.75,
+ "val_loss": 1.727276,
+ "val_acc": 42.2
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.681799,
+ "gbest_acc": 44.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.681799,
+ "gbest_acc": 44.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.661754,
+ "gbest_acc": 44.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.656639,
+ "gbest_acc": 44.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.656639,
+ "gbest_acc": 44.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.656079,
+ "gbest_acc": 44.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.648248,
+ "gbest_acc": 43.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.642714,
+ "gbest_acc": 45.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.642714,
+ "gbest_acc": 45.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.642714,
+ "gbest_acc": 45.25,
+ "val_loss": 1.691618,
+ "val_acc": 43.29
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.618805,
+ "gbest_acc": 47.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.618805,
+ "gbest_acc": 47.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.599923,
+ "gbest_acc": 47.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.599923,
+ "gbest_acc": 47.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.599923,
+ "gbest_acc": 47.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.599923,
+ "gbest_acc": 47.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.590378,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.584632,
+ "gbest_acc": 47.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.584632,
+ "gbest_acc": 47.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.576327,
+ "gbest_acc": 49.05,
+ "val_loss": 1.632185,
+ "val_acc": 46.72
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.574419,
+ "gbest_acc": 49.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.564718,
+ "gbest_acc": 50.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.55848,
+ "gbest_acc": 48.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.55148,
+ "gbest_acc": 50.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.523769,
+ "gbest_acc": 50.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.512382,
+ "gbest_acc": 53.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.507042,
+ "gbest_acc": 51.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.499844,
+ "gbest_acc": 52.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.481997,
+ "gbest_acc": 53.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.47558,
+ "gbest_acc": 52.5,
+ "val_loss": 1.536835,
+ "val_acc": 49.09
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.47558,
+ "gbest_acc": 52.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.47558,
+ "gbest_acc": 52.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474314,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474314,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474314,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.465071,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452196,
+ "gbest_acc": 52.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.452196,
+ "gbest_acc": 52.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.433057,
+ "gbest_acc": 54.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.433057,
+ "gbest_acc": 54.6,
+ "val_loss": 1.496624,
+ "val_acc": 50.63
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.431054,
+ "gbest_acc": 53.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.423613,
+ "gbest_acc": 54.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.41836,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.399859,
+ "gbest_acc": 55.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.388518,
+ "gbest_acc": 54.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.38389,
+ "gbest_acc": 55.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.380144,
+ "gbest_acc": 53.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.380144,
+ "gbest_acc": 53.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.380144,
+ "gbest_acc": 53.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.378148,
+ "gbest_acc": 54.15,
+ "val_loss": 1.440742,
+ "val_acc": 51.27
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.378148,
+ "gbest_acc": 54.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.378148,
+ "gbest_acc": 54.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.36134,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357391,
+ "gbest_acc": 54.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.349367,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.348895,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.34134,
+ "gbest_acc": 58.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.334369,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.33206,
+ "gbest_acc": 56.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.33206,
+ "gbest_acc": 56.6,
+ "val_loss": 1.393573,
+ "val_acc": 53.57
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.326479,
+ "gbest_acc": 58.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.313742,
+ "gbest_acc": 59.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.312688,
+ "gbest_acc": 58.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.311805,
+ "gbest_acc": 59.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.311805,
+ "gbest_acc": 59.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.301076,
+ "gbest_acc": 59.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.298557,
+ "gbest_acc": 60.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.298352,
+ "gbest_acc": 59.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.296019,
+ "gbest_acc": 59.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.289547,
+ "gbest_acc": 59.55,
+ "val_loss": 1.347633,
+ "val_acc": 58.18
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282772,
+ "gbest_acc": 59.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282772,
+ "gbest_acc": 59.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.282772,
+ "gbest_acc": 59.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.28153,
+ "gbest_acc": 59.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.271947,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.253498,
+ "gbest_acc": 61.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.253498,
+ "gbest_acc": 61.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.253498,
+ "gbest_acc": 61.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.238798,
+ "gbest_acc": 62.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.237215,
+ "gbest_acc": 62.4,
+ "val_loss": 1.302051,
+ "val_acc": 59.53
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.226809,
+ "gbest_acc": 63.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.221308,
+ "gbest_acc": 61.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.20915,
+ "gbest_acc": 63.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.200485,
+ "gbest_acc": 63.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.190487,
+ "gbest_acc": 62.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.176096,
+ "gbest_acc": 63.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.15428,
+ "gbest_acc": 64.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136401,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136401,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136401,
+ "gbest_acc": 64.45,
+ "val_loss": 1.190695,
+ "val_acc": 62.53
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136401,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136401,
+ "gbest_acc": 64.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.130512,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.130512,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.124619,
+ "gbest_acc": 64.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.120104,
+ "gbest_acc": 64.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.114364,
+ "gbest_acc": 65.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.111627,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.109958,
+ "gbest_acc": 65.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.108095,
+ "gbest_acc": 64.85,
+ "val_loss": 1.157127,
+ "val_acc": 64.12
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.108095,
+ "gbest_acc": 64.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.105296,
+ "gbest_acc": 65.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.099184,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.094836,
+ "gbest_acc": 66.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.091118,
+ "gbest_acc": 66.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.088371,
+ "gbest_acc": 66.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.080286,
+ "gbest_acc": 66.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.073145,
+ "gbest_acc": 67.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.06531,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.06531,
+ "gbest_acc": 67.7,
+ "val_loss": 1.11628,
+ "val_acc": 65.76
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G4",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "velocity x mutation interaction"
+ }
+ },
+ "G5": {
+ "config_id": "G5",
+ "gbest_loss": 0.87666,
+ "gbest_acc": 71.9,
+ "gbest_val_loss": 0.90151,
+ "gbest_val_acc": 70.93,
+ "val_selected_particle_idx": 3,
+ "val_selected_loss": 0.90151,
+ "val_selected_acc": 70.93,
+ "val_metrics": {
+ "accuracy": 70.93,
+ "nll": 0.90151,
+ "brier": 0.410921,
+ "ece": 0.060203,
+ "margin": 0.48728
+ },
+ "wall_time_sec": 6.76,
+ "optimization_wall_time_sec": 6.5753,
+ "validation_wall_time_sec": 0.1847,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 88,
+ "final_moment_steps": [
+ 31,
+ 46,
+ 47,
+ 118,
+ 13,
+ 16,
+ 41,
+ 42,
+ 41,
+ 76,
+ 160,
+ 28,
+ 3,
+ 11,
+ 43,
+ 59,
+ 14,
+ 56,
+ 8,
+ 107,
+ 4,
+ 36,
+ 17,
+ 41,
+ 34,
+ 17,
+ 31,
+ 88,
+ 4,
+ 83
+ ],
+ "pbest_update_counts": 2066,
+ "boundary_hits": 62745,
+ "boundary_occupancy": 0.001437,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.171313,
+ "position_radius": 12.260184,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.319009,
+ "gbest_acc": 7.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.303509,
+ "gbest_acc": 9.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.296052,
+ "gbest_acc": 9.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.262821,
+ "gbest_acc": 10.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.244346,
+ "gbest_acc": 12.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.22311,
+ "gbest_acc": 15.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.19362,
+ "gbest_acc": 12.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.173948,
+ "gbest_acc": 12.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.158491,
+ "gbest_acc": 17.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.128641,
+ "gbest_acc": 16.15,
+ "val_loss": 2.123287,
+ "val_acc": 16.73
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.10669,
+ "gbest_acc": 17.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.10669,
+ "gbest_acc": 17.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.076173,
+ "gbest_acc": 18.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.026621,
+ "gbest_acc": 23.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.959617,
+ "gbest_acc": 26.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.866877,
+ "gbest_acc": 30.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.819121,
+ "gbest_acc": 36.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.819121,
+ "gbest_acc": 36.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.780743,
+ "gbest_acc": 38.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.774729,
+ "gbest_acc": 39.75,
+ "val_loss": 1.77838,
+ "val_acc": 39.43
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.688082,
+ "gbest_acc": 43.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687632,
+ "gbest_acc": 41.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687632,
+ "gbest_acc": 41.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.673908,
+ "gbest_acc": 43.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.653132,
+ "gbest_acc": 43.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.642928,
+ "gbest_acc": 43.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.628932,
+ "gbest_acc": 44.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.628932,
+ "gbest_acc": 44.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.626379,
+ "gbest_acc": 45.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.626379,
+ "gbest_acc": 45.55,
+ "val_loss": 1.642554,
+ "val_acc": 44.6
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.617016,
+ "gbest_acc": 46.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.608258,
+ "gbest_acc": 46.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548058,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548058,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548058,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548058,
+ "gbest_acc": 49.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.51832,
+ "gbest_acc": 49.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.51832,
+ "gbest_acc": 49.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.51832,
+ "gbest_acc": 49.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.509292,
+ "gbest_acc": 50.4,
+ "val_loss": 1.520981,
+ "val_acc": 49.39
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.499409,
+ "gbest_acc": 50.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.496912,
+ "gbest_acc": 49.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.476928,
+ "gbest_acc": 51.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.475891,
+ "gbest_acc": 51.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.465416,
+ "gbest_acc": 51.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.457626,
+ "gbest_acc": 52.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.457626,
+ "gbest_acc": 52.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.457626,
+ "gbest_acc": 52.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.443585,
+ "gbest_acc": 53.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.435169,
+ "gbest_acc": 52.5,
+ "val_loss": 1.450692,
+ "val_acc": 52.98
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.435169,
+ "gbest_acc": 52.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.406087,
+ "gbest_acc": 54.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.402892,
+ "gbest_acc": 54.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.379921,
+ "gbest_acc": 51.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332886,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332886,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332886,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.332886,
+ "gbest_acc": 54.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331518,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.277132,
+ "gbest_acc": 57.8,
+ "val_loss": 1.288821,
+ "val_acc": 57.61
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.277132,
+ "gbest_acc": 57.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.277132,
+ "gbest_acc": 57.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.273769,
+ "gbest_acc": 58.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.262137,
+ "gbest_acc": 58.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26008,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26008,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26008,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26008,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.26008,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.253803,
+ "gbest_acc": 57.55,
+ "val_loss": 1.26665,
+ "val_acc": 57.74
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.249793,
+ "gbest_acc": 58.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.243862,
+ "gbest_acc": 58.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.24209,
+ "gbest_acc": 58.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.236166,
+ "gbest_acc": 59.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.228308,
+ "gbest_acc": 59.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.228308,
+ "gbest_acc": 59.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.226109,
+ "gbest_acc": 59.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.222782,
+ "gbest_acc": 58.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.221923,
+ "gbest_acc": 59.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.2132,
+ "gbest_acc": 60.0,
+ "val_loss": 1.228897,
+ "val_acc": 59.21
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.195836,
+ "gbest_acc": 59.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.188061,
+ "gbest_acc": 61.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.188061,
+ "gbest_acc": 61.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.184243,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.184243,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.18185,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.180844,
+ "gbest_acc": 62.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.17235,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.17235,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.16785,
+ "gbest_acc": 61.55,
+ "val_loss": 1.19235,
+ "val_acc": 60.48
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.159835,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.157449,
+ "gbest_acc": 62.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.147835,
+ "gbest_acc": 62.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.146912,
+ "gbest_acc": 63.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.131573,
+ "gbest_acc": 63.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.120912,
+ "gbest_acc": 63.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.120912,
+ "gbest_acc": 63.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.118666,
+ "gbest_acc": 63.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.101176,
+ "gbest_acc": 64.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.097438,
+ "gbest_acc": 64.05,
+ "val_loss": 1.126786,
+ "val_acc": 63.18
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.097438,
+ "gbest_acc": 64.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.07454,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.072343,
+ "gbest_acc": 65.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.072343,
+ "gbest_acc": 65.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.069028,
+ "gbest_acc": 65.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.055623,
+ "gbest_acc": 65.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.049842,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.049842,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.044047,
+ "gbest_acc": 66.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.04235,
+ "gbest_acc": 66.75,
+ "val_loss": 1.074293,
+ "val_acc": 64.94
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.029091,
+ "gbest_acc": 66.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023243,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023243,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023243,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.023243,
+ "gbest_acc": 66.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.017569,
+ "gbest_acc": 66.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.017569,
+ "gbest_acc": 66.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.008633,
+ "gbest_acc": 66.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.004002,
+ "gbest_acc": 67.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.00061,
+ "gbest_acc": 66.8,
+ "val_loss": 1.030409,
+ "val_acc": 66.14
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.00061,
+ "gbest_acc": 66.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.999347,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.999347,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.999347,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993094,
+ "gbest_acc": 66.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.986082,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.981956,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.981956,
+ "gbest_acc": 67.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.973175,
+ "gbest_acc": 67.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972542,
+ "gbest_acc": 67.45,
+ "val_loss": 0.995518,
+ "val_acc": 67.59
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.971742,
+ "gbest_acc": 67.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.966672,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.966672,
+ "gbest_acc": 68.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.959388,
+ "gbest_acc": 68.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.959143,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.956071,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.948034,
+ "gbest_acc": 68.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.941507,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.937224,
+ "gbest_acc": 68.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.929362,
+ "gbest_acc": 69.65,
+ "val_loss": 0.949647,
+ "val_acc": 69.34
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92441,
+ "gbest_acc": 69.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92441,
+ "gbest_acc": 69.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.92441,
+ "gbest_acc": 69.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.922341,
+ "gbest_acc": 69.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.917089,
+ "gbest_acc": 70.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.907896,
+ "gbest_acc": 70.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.900849,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.900849,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.900849,
+ "gbest_acc": 70.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.897977,
+ "gbest_acc": 70.3,
+ "val_loss": 0.923239,
+ "val_acc": 69.82
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.896607,
+ "gbest_acc": 70.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.894509,
+ "gbest_acc": 70.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.891321,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.891321,
+ "gbest_acc": 70.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.891038,
+ "gbest_acc": 70.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.887064,
+ "gbest_acc": 71.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884475,
+ "gbest_acc": 71.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.884475,
+ "gbest_acc": 71.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.879805,
+ "gbest_acc": 71.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.87666,
+ "gbest_acc": 71.9,
+ "val_loss": 0.90151,
+ "val_acc": 70.93
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G5",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test sufficient bound expansion"
+ }
+ },
+ "G6": {
+ "config_id": "G6",
+ "gbest_loss": 0.961326,
+ "gbest_acc": 69.05,
+ "gbest_val_loss": 0.96129,
+ "gbest_val_acc": 69.56,
+ "val_selected_particle_idx": 12,
+ "val_selected_loss": 0.96129,
+ "val_selected_acc": 69.56,
+ "val_metrics": {
+ "accuracy": 69.56,
+ "nll": 0.96129,
+ "brier": 0.429042,
+ "ece": 0.06558,
+ "margin": 0.465525
+ },
+ "wall_time_sec": 6.7408,
+ "optimization_wall_time_sec": 6.554,
+ "validation_wall_time_sec": 0.1868,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 88,
+ "final_moment_steps": [
+ 31,
+ 46,
+ 47,
+ 118,
+ 13,
+ 16,
+ 41,
+ 42,
+ 41,
+ 76,
+ 160,
+ 28,
+ 3,
+ 11,
+ 43,
+ 59,
+ 14,
+ 56,
+ 8,
+ 107,
+ 4,
+ 36,
+ 17,
+ 41,
+ 34,
+ 17,
+ 31,
+ 88,
+ 4,
+ 83
+ ],
+ "pbest_update_counts": 2143,
+ "boundary_hits": 91538,
+ "boundary_occupancy": 0.002096,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.27561,
+ "position_radius": 18.448799,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.325288,
+ "gbest_acc": 7.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.30952,
+ "gbest_acc": 11.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.30333,
+ "gbest_acc": 12.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.27474,
+ "gbest_acc": 17.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.257845,
+ "gbest_acc": 14.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.206771,
+ "gbest_acc": 22.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.166269,
+ "gbest_acc": 25.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.166269,
+ "gbest_acc": 25.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.068628,
+ "gbest_acc": 31.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.035147,
+ "gbest_acc": 27.85,
+ "val_loss": 2.046996,
+ "val_acc": 27.34
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.026116,
+ "gbest_acc": 33.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.984777,
+ "gbest_acc": 30.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.908976,
+ "gbest_acc": 34.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.908976,
+ "gbest_acc": 34.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.907655,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.90281,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.899526,
+ "gbest_acc": 35.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.895408,
+ "gbest_acc": 34.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.873505,
+ "gbest_acc": 34.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.873505,
+ "gbest_acc": 34.7,
+ "val_loss": 1.885487,
+ "val_acc": 34.91
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.873505,
+ "gbest_acc": 34.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.866245,
+ "gbest_acc": 34.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.833964,
+ "gbest_acc": 36.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.817472,
+ "gbest_acc": 36.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.817472,
+ "gbest_acc": 36.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.810248,
+ "gbest_acc": 36.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.810248,
+ "gbest_acc": 36.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.809053,
+ "gbest_acc": 36.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.809053,
+ "gbest_acc": 36.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.799193,
+ "gbest_acc": 37.6,
+ "val_loss": 1.80777,
+ "val_acc": 37.76
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.79631,
+ "gbest_acc": 39.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.78926,
+ "gbest_acc": 37.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.770977,
+ "gbest_acc": 38.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.770977,
+ "gbest_acc": 38.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76754,
+ "gbest_acc": 39.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76754,
+ "gbest_acc": 39.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76754,
+ "gbest_acc": 39.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.754465,
+ "gbest_acc": 40.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.754465,
+ "gbest_acc": 40.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.736352,
+ "gbest_acc": 40.35,
+ "val_loss": 1.740964,
+ "val_acc": 39.54
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730599,
+ "gbest_acc": 38.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730599,
+ "gbest_acc": 38.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.730599,
+ "gbest_acc": 38.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711387,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711387,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711387,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.711387,
+ "gbest_acc": 41.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.68994,
+ "gbest_acc": 42.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.68994,
+ "gbest_acc": 42.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.68994,
+ "gbest_acc": 42.0,
+ "val_loss": 1.694976,
+ "val_acc": 43.17
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.68994,
+ "gbest_acc": 42.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.68994,
+ "gbest_acc": 42.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.67567,
+ "gbest_acc": 42.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.646899,
+ "gbest_acc": 43.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.646899,
+ "gbest_acc": 43.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.646899,
+ "gbest_acc": 43.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.641969,
+ "gbest_acc": 43.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.641969,
+ "gbest_acc": 43.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.629627,
+ "gbest_acc": 44.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.621204,
+ "gbest_acc": 44.8,
+ "val_loss": 1.62915,
+ "val_acc": 45.81
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.619025,
+ "gbest_acc": 44.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.607883,
+ "gbest_acc": 44.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.595301,
+ "gbest_acc": 46.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581446,
+ "gbest_acc": 46.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581446,
+ "gbest_acc": 46.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.56116,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.56116,
+ "gbest_acc": 46.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5547,
+ "gbest_acc": 46.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.5547,
+ "gbest_acc": 46.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.547316,
+ "gbest_acc": 45.8,
+ "val_loss": 1.560907,
+ "val_acc": 47.36
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.539633,
+ "gbest_acc": 47.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.52906,
+ "gbest_acc": 47.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.521271,
+ "gbest_acc": 48.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.511641,
+ "gbest_acc": 49.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.501456,
+ "gbest_acc": 49.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.495384,
+ "gbest_acc": 50.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.495384,
+ "gbest_acc": 50.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.477692,
+ "gbest_acc": 50.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.465775,
+ "gbest_acc": 50.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.465775,
+ "gbest_acc": 50.5,
+ "val_loss": 1.487023,
+ "val_acc": 50.61
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.463173,
+ "gbest_acc": 50.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.428135,
+ "gbest_acc": 52.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.428135,
+ "gbest_acc": 52.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.416037,
+ "gbest_acc": 52.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.413407,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.405569,
+ "gbest_acc": 53.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.390931,
+ "gbest_acc": 53.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.372991,
+ "gbest_acc": 53.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.372991,
+ "gbest_acc": 53.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357691,
+ "gbest_acc": 54.05,
+ "val_loss": 1.370485,
+ "val_acc": 54.93
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357691,
+ "gbest_acc": 54.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.357691,
+ "gbest_acc": 54.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.355001,
+ "gbest_acc": 54.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338486,
+ "gbest_acc": 56.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.338486,
+ "gbest_acc": 56.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.333933,
+ "gbest_acc": 55.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.31521,
+ "gbest_acc": 57.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.308802,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.292441,
+ "gbest_acc": 57.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.292441,
+ "gbest_acc": 57.75,
+ "val_loss": 1.305631,
+ "val_acc": 58.03
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.287728,
+ "gbest_acc": 57.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.285697,
+ "gbest_acc": 58.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.276035,
+ "gbest_acc": 59.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.256802,
+ "gbest_acc": 60.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.256338,
+ "gbest_acc": 60.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.243438,
+ "gbest_acc": 60.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.243303,
+ "gbest_acc": 60.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.243303,
+ "gbest_acc": 60.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.232502,
+ "gbest_acc": 61.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.228855,
+ "gbest_acc": 60.95,
+ "val_loss": 1.23967,
+ "val_acc": 60.87
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.213689,
+ "gbest_acc": 61.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.213689,
+ "gbest_acc": 61.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.21292,
+ "gbest_acc": 61.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.212314,
+ "gbest_acc": 62.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.199686,
+ "gbest_acc": 62.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.194835,
+ "gbest_acc": 62.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.190278,
+ "gbest_acc": 62.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.188638,
+ "gbest_acc": 62.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177123,
+ "gbest_acc": 62.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.177123,
+ "gbest_acc": 62.5,
+ "val_loss": 1.190327,
+ "val_acc": 62.66
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.169856,
+ "gbest_acc": 62.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.160888,
+ "gbest_acc": 63.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.15864,
+ "gbest_acc": 63.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.15864,
+ "gbest_acc": 63.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.154944,
+ "gbest_acc": 63.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.149841,
+ "gbest_acc": 63.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.141024,
+ "gbest_acc": 64.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.136587,
+ "gbest_acc": 62.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.132175,
+ "gbest_acc": 63.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.124431,
+ "gbest_acc": 64.55,
+ "val_loss": 1.133461,
+ "val_acc": 64.36
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.119002,
+ "gbest_acc": 64.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.11873,
+ "gbest_acc": 64.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.107671,
+ "gbest_acc": 65.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.105437,
+ "gbest_acc": 64.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.092362,
+ "gbest_acc": 65.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.092362,
+ "gbest_acc": 65.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.087102,
+ "gbest_acc": 65.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.084745,
+ "gbest_acc": 65.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.083938,
+ "gbest_acc": 64.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.075225,
+ "gbest_acc": 65.95,
+ "val_loss": 1.080466,
+ "val_acc": 66.2
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.070469,
+ "gbest_acc": 65.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.070227,
+ "gbest_acc": 66.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.065267,
+ "gbest_acc": 65.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.054889,
+ "gbest_acc": 66.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.044873,
+ "gbest_acc": 68.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.039123,
+ "gbest_acc": 68.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.030557,
+ "gbest_acc": 67.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.019085,
+ "gbest_acc": 68.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.011961,
+ "gbest_acc": 67.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.011484,
+ "gbest_acc": 68.0,
+ "val_loss": 1.010008,
+ "val_acc": 68.36
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.998134,
+ "gbest_acc": 69.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.993379,
+ "gbest_acc": 68.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.987521,
+ "gbest_acc": 69.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.98132,
+ "gbest_acc": 67.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972304,
+ "gbest_acc": 69.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972304,
+ "gbest_acc": 69.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.972304,
+ "gbest_acc": 69.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.969385,
+ "gbest_acc": 69.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.967466,
+ "gbest_acc": 68.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 0.961326,
+ "gbest_acc": 69.05,
+ "val_loss": 0.96129,
+ "val_acc": 69.56
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G6",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "antithetic",
+ "position_radius": 1.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 6.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "test broader normalized initialization"
+ }
+ },
+ "G7": {
+ "config_id": "G7",
+ "gbest_loss": 1.286895,
+ "gbest_acc": 59.85,
+ "gbest_val_loss": 1.291266,
+ "gbest_val_acc": 58.79,
+ "val_selected_particle_idx": 5,
+ "val_selected_loss": 1.291266,
+ "val_selected_acc": 58.79,
+ "val_metrics": {
+ "accuracy": 58.79,
+ "nll": 1.291266,
+ "brier": 0.58435,
+ "ece": 0.169163,
+ "margin": 0.234253
+ },
+ "wall_time_sec": 6.4273,
+ "optimization_wall_time_sec": 6.2459,
+ "validation_wall_time_sec": 0.1814,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 47,
+ "official_test_evaluations": 0,
+ "mutation_events": 0,
+ "final_moment_steps": [
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160,
+ 160
+ ],
+ "pbest_update_counts": 2482,
+ "boundary_hits": 228313,
+ "boundary_occupancy": 0.005228,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.267674,
+ "position_radius": 16.999327,
+ "stage_histories": [
+ {
+ "epoch": 1,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.309139,
+ "gbest_acc": 7.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 2,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.299011,
+ "gbest_acc": 9.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 3,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.287127,
+ "gbest_acc": 11.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 4,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.27862,
+ "gbest_acc": 11.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 5,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.255058,
+ "gbest_acc": 14.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 6,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.23202,
+ "gbest_acc": 15.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 7,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.23202,
+ "gbest_acc": 15.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 8,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.227222,
+ "gbest_acc": 17.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 9,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.214962,
+ "gbest_acc": 22.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 10,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.201656,
+ "gbest_acc": 25.35,
+ "val_loss": 2.197669,
+ "val_acc": 26.38
+ },
+ {
+ "epoch": 11,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.175992,
+ "gbest_acc": 21.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 12,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.174001,
+ "gbest_acc": 24.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 13,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.171524,
+ "gbest_acc": 22.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 14,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.171524,
+ "gbest_acc": 22.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 15,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.16751,
+ "gbest_acc": 21.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 16,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.141776,
+ "gbest_acc": 24.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 17,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.141776,
+ "gbest_acc": 24.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 18,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.120553,
+ "gbest_acc": 25.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 19,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.118536,
+ "gbest_acc": 24.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 20,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.116341,
+ "gbest_acc": 28.7,
+ "val_loss": 2.103779,
+ "val_acc": 28.58
+ },
+ {
+ "epoch": 21,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.086713,
+ "gbest_acc": 28.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 22,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.086713,
+ "gbest_acc": 28.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 23,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.078963,
+ "gbest_acc": 30.2,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 24,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.061015,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 25,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.061015,
+ "gbest_acc": 32.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 26,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.042015,
+ "gbest_acc": 31.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 27,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.040004,
+ "gbest_acc": 32.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 28,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.028711,
+ "gbest_acc": 27.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 29,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 2.025341,
+ "gbest_acc": 31.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 30,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.998952,
+ "gbest_acc": 33.6,
+ "val_loss": 1.99407,
+ "val_acc": 33.57
+ },
+ {
+ "epoch": 31,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.998952,
+ "gbest_acc": 33.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 32,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.99236,
+ "gbest_acc": 36.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 33,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.99236,
+ "gbest_acc": 36.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 34,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.990788,
+ "gbest_acc": 33.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 35,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.977843,
+ "gbest_acc": 32.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 36,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.973256,
+ "gbest_acc": 30.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 37,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.961657,
+ "gbest_acc": 33.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 38,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.961657,
+ "gbest_acc": 33.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 39,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.961657,
+ "gbest_acc": 33.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 40,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.950446,
+ "gbest_acc": 35.1,
+ "val_loss": 1.952211,
+ "val_acc": 34.13
+ },
+ {
+ "epoch": 41,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.939352,
+ "gbest_acc": 33.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 42,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.917866,
+ "gbest_acc": 35.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 43,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.905276,
+ "gbest_acc": 36.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 44,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.900597,
+ "gbest_acc": 37.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 45,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.900597,
+ "gbest_acc": 37.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 46,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.884362,
+ "gbest_acc": 41.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 47,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.884362,
+ "gbest_acc": 41.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 48,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.883041,
+ "gbest_acc": 40.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 49,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.870878,
+ "gbest_acc": 38.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 50,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.85983,
+ "gbest_acc": 39.1,
+ "val_loss": 1.855194,
+ "val_acc": 38.47
+ },
+ {
+ "epoch": 51,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.848652,
+ "gbest_acc": 39.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 52,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.845486,
+ "gbest_acc": 40.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 53,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.839194,
+ "gbest_acc": 39.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 54,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.834288,
+ "gbest_acc": 40.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 55,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.818126,
+ "gbest_acc": 41.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 56,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.818126,
+ "gbest_acc": 41.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 57,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.816245,
+ "gbest_acc": 41.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 58,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.812257,
+ "gbest_acc": 42.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 59,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.810906,
+ "gbest_acc": 43.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 60,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.807155,
+ "gbest_acc": 42.2,
+ "val_loss": 1.813947,
+ "val_acc": 41.75
+ },
+ {
+ "epoch": 61,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.801779,
+ "gbest_acc": 43.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 62,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.777376,
+ "gbest_acc": 44.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 63,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.775451,
+ "gbest_acc": 43.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 64,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76432,
+ "gbest_acc": 42.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 65,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76432,
+ "gbest_acc": 42.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 66,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.76432,
+ "gbest_acc": 42.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 67,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.758181,
+ "gbest_acc": 44.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 68,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.758181,
+ "gbest_acc": 44.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 69,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.745974,
+ "gbest_acc": 46.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 70,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.745032,
+ "gbest_acc": 47.1,
+ "val_loss": 1.747376,
+ "val_acc": 46.71
+ },
+ {
+ "epoch": 71,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.735996,
+ "gbest_acc": 46.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 72,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.726349,
+ "gbest_acc": 47.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 73,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.726349,
+ "gbest_acc": 47.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 74,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.726349,
+ "gbest_acc": 47.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 75,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.709275,
+ "gbest_acc": 47.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 76,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.709275,
+ "gbest_acc": 47.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 77,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.689212,
+ "gbest_acc": 47.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 78,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.689212,
+ "gbest_acc": 47.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 79,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.687616,
+ "gbest_acc": 47.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 80,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.682901,
+ "gbest_acc": 47.65,
+ "val_loss": 1.677802,
+ "val_acc": 48.27
+ },
+ {
+ "epoch": 81,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.682901,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 82,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.682901,
+ "gbest_acc": 47.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 83,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.675636,
+ "gbest_acc": 48.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 84,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.66942,
+ "gbest_acc": 48.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 85,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.665965,
+ "gbest_acc": 48.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 86,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.654253,
+ "gbest_acc": 49.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 87,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.643053,
+ "gbest_acc": 50.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 88,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.643053,
+ "gbest_acc": 50.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 89,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.630918,
+ "gbest_acc": 50.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 90,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.625607,
+ "gbest_acc": 51.05,
+ "val_loss": 1.622408,
+ "val_acc": 50.7
+ },
+ {
+ "epoch": 91,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.605352,
+ "gbest_acc": 50.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 92,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.605352,
+ "gbest_acc": 50.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 93,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.589749,
+ "gbest_acc": 50.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 94,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.589749,
+ "gbest_acc": 50.0,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 95,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581419,
+ "gbest_acc": 52.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 96,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581419,
+ "gbest_acc": 52.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 97,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.581419,
+ "gbest_acc": 52.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 98,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.570031,
+ "gbest_acc": 53.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 99,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.558124,
+ "gbest_acc": 51.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 100,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.551278,
+ "gbest_acc": 50.1,
+ "val_loss": 1.54449,
+ "val_acc": 50.36
+ },
+ {
+ "epoch": 101,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.548868,
+ "gbest_acc": 51.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 102,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.544148,
+ "gbest_acc": 52.55,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 103,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.532144,
+ "gbest_acc": 52.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 104,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.527366,
+ "gbest_acc": 53.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 105,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.527366,
+ "gbest_acc": 53.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 106,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.525305,
+ "gbest_acc": 54.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 107,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.520576,
+ "gbest_acc": 54.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 108,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.514018,
+ "gbest_acc": 54.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 109,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.506088,
+ "gbest_acc": 55.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 110,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.505858,
+ "gbest_acc": 54.6,
+ "val_loss": 1.505211,
+ "val_acc": 54.28
+ },
+ {
+ "epoch": 111,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.501922,
+ "gbest_acc": 55.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 112,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.499061,
+ "gbest_acc": 54.7,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 113,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.495314,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 114,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.491583,
+ "gbest_acc": 55.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 115,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.474219,
+ "gbest_acc": 56.9,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 116,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.470855,
+ "gbest_acc": 55.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 117,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.456732,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 118,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.455199,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 119,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.455199,
+ "gbest_acc": 56.15,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 120,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.455199,
+ "gbest_acc": 56.15,
+ "val_loss": 1.453086,
+ "val_acc": 55.69
+ },
+ {
+ "epoch": 121,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.450464,
+ "gbest_acc": 55.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 122,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.441264,
+ "gbest_acc": 56.35,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 123,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.438647,
+ "gbest_acc": 56.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 124,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.432057,
+ "gbest_acc": 55.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 125,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.424615,
+ "gbest_acc": 56.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 126,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.422398,
+ "gbest_acc": 55.65,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 127,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.418894,
+ "gbest_acc": 56.1,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 128,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.414879,
+ "gbest_acc": 56.4,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 129,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.410718,
+ "gbest_acc": 57.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 130,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.405867,
+ "gbest_acc": 56.55,
+ "val_loss": 1.407187,
+ "val_acc": 55.96
+ },
+ {
+ "epoch": 131,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.396443,
+ "gbest_acc": 57.75,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 132,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.385648,
+ "gbest_acc": 56.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 133,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.377888,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 134,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.369016,
+ "gbest_acc": 57.95,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 135,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.36734,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 136,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.362107,
+ "gbest_acc": 57.05,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 137,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.360926,
+ "gbest_acc": 56.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 138,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.360926,
+ "gbest_acc": 56.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 139,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.360926,
+ "gbest_acc": 56.8,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 140,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.356624,
+ "gbest_acc": 57.7,
+ "val_loss": 1.363448,
+ "val_acc": 56.94
+ },
+ {
+ "epoch": 141,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.354778,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 142,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.353311,
+ "gbest_acc": 57.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 143,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.347267,
+ "gbest_acc": 57.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 144,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.340002,
+ "gbest_acc": 58.25,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 145,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.337986,
+ "gbest_acc": 57.85,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 146,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.336033,
+ "gbest_acc": 58.3,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 147,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.331574,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 148,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.328634,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 149,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.324152,
+ "gbest_acc": 58.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 150,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.324152,
+ "gbest_acc": 58.6,
+ "val_loss": 1.330312,
+ "val_acc": 57.4
+ },
+ {
+ "epoch": 151,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.319941,
+ "gbest_acc": 59.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 152,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.319941,
+ "gbest_acc": 59.45,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 153,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.317319,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 154,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.317319,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 155,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.314964,
+ "gbest_acc": 60.5,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 156,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.311068,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 157,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.299587,
+ "gbest_acc": 61.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 158,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.297939,
+ "gbest_acc": 60.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 159,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.296547,
+ "gbest_acc": 59.6,
+ "val_loss": null,
+ "val_acc": null
+ },
+ {
+ "epoch": 160,
+ "stage": 0,
+ "subset_size": 2000,
+ "gbest_loss": 1.286895,
+ "gbest_acc": 59.85,
+ "val_loss": 1.291266,
+ "val_acc": 58.79
+ }
+ ],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G7",
+ "scale_type": "per_tensor_sd",
+ "init_position_mode": "independent",
+ "position_radius": 0.5,
+ "initial_velocity_radius": 0.5,
+ "mutation_prob": 0.0,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "isolate antithetic position coupling against G2"
+ }
+ },
+ "G8": {
+ "config_id": "G8",
+ "gbest_loss": 0.858659,
+ "gbest_acc": 73.15,
+ "val_selected_loss": 0.883557,
+ "val_selected_acc": 70.99,
+ "val_metrics": {
+ "accuracy": 70.99,
+ "nll": 0.883557,
+ "brier": 0.402781,
+ "ece": 0.025241,
+ "margin": 0.533326
+ },
+ "wall_time_sec": 8.7632,
+ "optimization_wall_time_sec": 8.4371,
+ "validation_wall_time_sec": 0.326,
+ "total_queries": 4800,
+ "total_sample_evaluations": 9600000,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": 31,
+ "official_test_evaluations": 0,
+ "pbest_update_counts": 0,
+ "boundary_hits": 0,
+ "boundary_occupancy": 0.0,
+ "last_improvement_epoch": 160,
+ "velocity_rms": 0.0,
+ "position_radius": 0.0,
+ "stage_histories": [],
+ "seed": 91,
+ "geometry_config": {
+ "config_id": "G8",
+ "scale_type": "optimizer_default",
+ "init_position_mode": "independent",
+ "position_radius": 0.05,
+ "initial_velocity_radius": 0.05,
+ "mutation_prob": 0.02,
+ "reset_velocity_radius": 0.02,
+ "reflective_bound": 3.0,
+ "projection_seed": null,
+ "latent_dim": "full",
+ "description": "retained semantic control (public Optimizer)"
+ }
+ }
+ },
+ "factor_deltas": {
+ "delta_scale_G1_vs_G0": {
+ "test_config": "G1",
+ "ref_config": "G0",
+ "nll_diff": 0.254487,
+ "acc_diff": -5.41,
+ "material": false,
+ "description": "global RMS scale vs per-tensor SD"
+ },
+ "delta_vel_G2_vs_G0": {
+ "test_config": "G2",
+ "ref_config": "G0",
+ "nll_diff": 0.112988,
+ "acc_diff": -7.01,
+ "material": false,
+ "description": "launch velocity U(-0.5,0.5) vs 0"
+ },
+ "delta_mut_G3_vs_G0": {
+ "test_config": "G3",
+ "ref_config": "G0",
+ "nll_diff": -0.052278,
+ "acc_diff": 0.34,
+ "material": true,
+ "description": "mutation 0.02 vs 0"
+ },
+ "delta_vel_mut_G4_vs_G2": {
+ "test_config": "G4",
+ "ref_config": "G2",
+ "nll_diff": -0.179825,
+ "acc_diff": 5.04,
+ "material": true,
+ "description": "mutation interaction given velocity"
+ },
+ "delta_bound_G5_vs_G4": {
+ "test_config": "G5",
+ "ref_config": "G4",
+ "nll_diff": -0.21477,
+ "acc_diff": 5.17,
+ "material": true,
+ "description": "bound box 6 vs 3"
+ },
+ "delta_radius_G6_vs_G5": {
+ "test_config": "G6",
+ "ref_config": "G5",
+ "nll_diff": 0.05978,
+ "acc_diff": -1.37,
+ "material": false,
+ "description": "initial position radius 1.5 vs 0.5"
+ },
+ "delta_init_G7_vs_G2": {
+ "test_config": "G7",
+ "ref_config": "G2",
+ "nll_diff": -0.004839,
+ "acc_diff": -1.93,
+ "material": false,
+ "description": "independent vs antithetic init"
+ },
+ "delta_bundle_G8_vs_best_norm": {
+ "test_config": "G8",
+ "ref_config": "G5",
+ "nll_diff": -0.017953,
+ "acc_diff": 0.06,
+ "material": false,
+ "description": "Optimizer G8 control vs best normalized (G5)"
+ }
+ },
+ "selected_for_confirm": [
+ "G0",
+ "G1",
+ "G8",
+ "G5",
+ "G6"
+ ]
+ }
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v7_heavy_cross_split.csv b/benchmark_results/pso_v7_heavy_cross_split.csv
new file mode 100644
index 0000000..f4d724e
--- /dev/null
+++ b/benchmark_results/pso_v7_heavy_cross_split.csv
@@ -0,0 +1,73 @@
+variant_id,phase,split_seed,workload_id,baseline_method,baseline_acc,candidate_acc,acc_gain_pp,baseline_nll,candidate_nll,nll_reduction_fraction,state_ratio,score,pass,is_best_observed,candidate_path,evaluation_path
+iteration-0001-development,development,20260905,mnist_compact,G8,50.713333,50.723333,0.00999999999999801,1.534298,1.492805,0.0270436381980554,0.4918032786885246,-289.2921035434933,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0001-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0001-development.json
+iteration-0001-development,development,20260905,mnist_wide,G5,46.656667,46.04,-0.6166669999999996,1.677872,1.675644,0.0013278724479579603,0.5,-289.2921035434933,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0001-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0001-development.json
+iteration-0001-development,development,20260905,fashion_compact,G8,46.366667,49.576667,3.210000000000001,1.497844,1.400574,0.06494000710354347,0.4918032786885246,-289.2921035434933,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0001-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0001-development.json
+iteration-0001-development,development,20260905,fashion_wide,G5,48.516667,45.01,-3.506667,1.490304,1.584923,-0.06348973095422142,0.5,-289.2921035434933,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0001-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0001-development.json
+iteration-0001-development,development,20260906,mnist_compact,G8,46.81,51.663333,4.853332999999999,1.58986,1.436337,0.09656384838916639,0.4918032786885246,-289.2921035434933,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0001-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0001-development.json
+iteration-0001-development,development,20260906,mnist_wide,G5,44.936667,44.83,-0.10666700000000162,1.665007,1.749135,-0.050527114901018556,0.5,-289.2921035434933,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0001-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0001-development.json
+iteration-0001-development,development,20260906,fashion_compact,G8,44.193333,48.753333,4.559999999999995,1.553097,1.375751,0.11418861796784104,0.4918032786885246,-289.2921035434933,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0001-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0001-development.json
+iteration-0001-development,development,20260906,fashion_wide,G5,48.37,41.193333,-7.176666999999995,1.490657,1.707819,-0.14568207173078723,0.5,-289.2921035434933,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0001-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0001-development.json
+iteration-0002-development,development,20260905,mnist_compact,G8,50.713333,50.723333,0.00999999999999801,1.534298,1.492805,0.0270436381980554,0.4918032786885246,-186.3459040597986,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0002-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0002-development.json
+iteration-0002-development,development,20260905,mnist_wide,G5,46.656667,45.193333,-1.4633339999999961,1.677872,1.733563,-0.03319144726176963,0.5,-186.3459040597986,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0002-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0002-development.json
+iteration-0002-development,development,20260905,fashion_compact,G8,46.366667,49.576667,3.210000000000001,1.497844,1.400574,0.06494000710354347,0.4918032786885246,-186.3459040597986,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0002-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0002-development.json
+iteration-0002-development,development,20260905,fashion_wide,G5,48.516667,47.223333,-1.2933340000000015,1.490304,1.536216,-0.03080713733573818,0.5,-186.3459040597986,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0002-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0002-development.json
+iteration-0002-development,development,20260906,mnist_compact,G8,46.81,51.663333,4.853332999999999,1.58986,1.436337,0.09656384838916639,0.4918032786885246,-186.3459040597986,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0002-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0002-development.json
+iteration-0002-development,development,20260906,mnist_wide,G5,44.936667,45.09,0.1533330000000035,1.665007,1.734207,-0.04156138682900441,0.5,-186.3459040597986,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0002-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0002-development.json
+iteration-0002-development,development,20260906,fashion_compact,G8,44.193333,48.753333,4.559999999999995,1.553097,1.375751,0.11418861796784104,0.4918032786885246,-186.3459040597986,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0002-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0002-development.json
+iteration-0002-development,development,20260906,fashion_wide,G5,48.37,46.813333,-1.5566669999999974,1.490657,1.475127,0.010418224984016995,0.5,-186.3459040597986,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0002-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0002-development.json
+iteration-0003-replica1-development,development,20260905,mnist_compact,G8,50.713333,50.723333,0.00999999999999801,1.534298,1.492805,0.0270436381980554,0.4918032786885246,-287.7250973286179,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica1-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica1-development.json
+iteration-0003-replica1-development,development,20260905,mnist_wide,G5,46.656667,44.923333,-1.7333339999999993,1.677872,1.728906,-0.030415907768888223,0.5,-287.7250973286179,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica1-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica1-development.json
+iteration-0003-replica1-development,development,20260905,fashion_compact,G8,46.366667,49.576667,3.210000000000001,1.497844,1.400574,0.06494000710354347,0.4918032786885246,-287.7250973286179,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica1-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica1-development.json
+iteration-0003-replica1-development,development,20260905,fashion_wide,G5,48.516667,47.176667,-1.3399999999999963,1.490304,1.56267,-0.048557878124194744,0.5,-287.7250973286179,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica1-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica1-development.json
+iteration-0003-replica1-development,development,20260906,mnist_compact,G8,46.81,51.663333,4.853332999999999,1.58986,1.436337,0.09656384838916639,0.4918032786885246,-287.7250973286179,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica1-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica1-development.json
+iteration-0003-replica1-development,development,20260906,mnist_wide,G5,44.936667,42.113333,-2.8233340000000027,1.665007,1.713134,-0.028904983582651624,0.5,-287.7250973286179,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica1-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica1-development.json
+iteration-0003-replica1-development,development,20260906,fashion_compact,G8,44.193333,48.753333,4.559999999999995,1.553097,1.375751,0.11418861796784104,0.4918032786885246,-287.7250973286179,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica1-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica1-development.json
+iteration-0003-replica1-development,development,20260906,fashion_wide,G5,48.37,46.433333,-1.936667,1.490657,1.581386,-0.06086510847230454,0.5,-287.7250973286179,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica1-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica1-development.json
+iteration-0003-replica2-development,development,20260905,mnist_compact,G8,50.713333,50.723333,0.00999999999999801,1.534298,1.492805,0.0270436381980554,0.4918032786885246,-286.97652369317115,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica2-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica2-development.json
+iteration-0003-replica2-development,development,20260905,mnist_wide,G5,46.656667,46.01,-0.6466670000000008,1.677872,1.72888,-0.0304004119503752,0.5,-286.97652369317115,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica2-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica2-development.json
+iteration-0003-replica2-development,development,20260905,fashion_compact,G8,46.366667,49.576667,3.210000000000001,1.497844,1.400574,0.06494000710354347,0.4918032786885246,-286.97652369317115,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica2-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica2-development.json
+iteration-0003-replica2-development,development,20260905,fashion_wide,G5,48.516667,48.613333,0.09666599999999903,1.490304,1.48049,0.006585233616765431,0.5,-286.97652369317115,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica2-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica2-development.json
+iteration-0003-replica2-development,development,20260906,mnist_compact,G8,46.81,51.663333,4.853332999999999,1.58986,1.436337,0.09656384838916639,0.4918032786885246,-286.97652369317115,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica2-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica2-development.json
+iteration-0003-replica2-development,development,20260906,mnist_wide,G5,44.936667,41.556667,-3.3800000000000026,1.665007,1.801698,-0.08209635154687045,0.5,-286.97652369317115,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica2-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica2-development.json
+iteration-0003-replica2-development,development,20260906,fashion_compact,G8,44.193333,48.753333,4.559999999999995,1.553097,1.375751,0.11418861796784104,0.4918032786885246,-286.97652369317115,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica2-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica2-development.json
+iteration-0003-replica2-development,development,20260906,fashion_wide,G5,48.37,45.913333,-2.456666999999996,1.490657,1.516614,-0.017413127231817923,0.5,-286.97652369317115,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0003-replica2-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0003-replica2-development.json
+iteration-0004-development,development,20260905,mnist_compact,G8,50.713333,50.723333,0.00999999999999801,1.534298,1.492805,0.0270436381980554,0.4918032786885246,-390.14004501856266,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0004-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0004-development.json
+iteration-0004-development,development,20260905,mnist_wide,G5,46.656667,44.763333,-1.8933339999999959,1.677872,1.698999,-0.012591544527830428,0.5,-390.14004501856266,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0004-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0004-development.json
+iteration-0004-development,development,20260905,fashion_compact,G8,46.366667,49.576667,3.210000000000001,1.497844,1.400574,0.06494000710354347,0.4918032786885246,-390.14004501856266,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0004-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0004-development.json
+iteration-0004-development,development,20260905,fashion_wide,G5,48.516667,44.816667,-3.6999999999999957,1.490304,1.582588,-0.06192293652838617,0.5,-390.14004501856266,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0004-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0004-development.json
+iteration-0004-development,development,20260906,mnist_compact,G8,46.81,51.663333,4.853332999999999,1.58986,1.436337,0.09656384838916639,0.4918032786885246,-390.14004501856266,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0004-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0004-development.json
+iteration-0004-development,development,20260906,mnist_wide,G5,44.936667,38.946667,-5.990000000000002,1.665007,1.819662,-0.09288549537629572,0.5,-390.14004501856266,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0004-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0004-development.json
+iteration-0004-development,development,20260906,fashion_compact,G8,44.193333,48.753333,4.559999999999995,1.553097,1.375751,0.11418861796784104,0.4918032786885246,-390.14004501856266,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0004-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0004-development.json
+iteration-0004-development,development,20260906,fashion_wide,G5,48.37,43.9,-4.469999999999999,1.490657,1.658117,-0.11233972671110803,0.5,-390.14004501856266,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0004-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0004-development.json
+iteration-0005-development,development,20260905,mnist_compact,G8,50.713333,50.723333,0.00999999999999801,1.534298,1.492805,0.0270436381980554,0.4918032786885246,-185.61068572934795,False,True,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0005-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0005-development.json
+iteration-0005-development,development,20260905,mnist_wide,G5,46.656667,43.723333,-2.933334000000002,1.677872,1.675155,0.0016193130346057866,0.5,-185.61068572934795,False,True,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0005-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0005-development.json
+iteration-0005-development,development,20260905,fashion_compact,G8,46.366667,49.576667,3.210000000000001,1.497844,1.400574,0.06494000710354347,0.4918032786885246,-185.61068572934795,False,True,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0005-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0005-development.json
+iteration-0005-development,development,20260905,fashion_wide,G5,48.516667,45.45,-3.0666669999999954,1.490304,1.441667,0.03263562333591002,0.5,-185.61068572934795,False,True,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0005-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0005-development.json
+iteration-0005-development,development,20260906,mnist_compact,G8,46.81,51.663333,4.853332999999999,1.58986,1.436337,0.09656384838916639,0.4918032786885246,-185.61068572934795,False,True,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0005-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0005-development.json
+iteration-0005-development,development,20260906,mnist_wide,G5,44.936667,42.543333,-2.393334000000003,1.665007,1.740544,-0.04536737683385127,0.5,-185.61068572934795,False,True,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0005-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0005-development.json
+iteration-0005-development,development,20260906,fashion_compact,G8,44.193333,48.753333,4.559999999999995,1.553097,1.375751,0.11418861796784104,0.4918032786885246,-185.61068572934795,False,True,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0005-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0005-development.json
+iteration-0005-development,development,20260906,fashion_wide,G5,48.37,47.65,-0.7199999999999989,1.490657,1.454402,0.02432149045689245,0.5,-185.61068572934795,False,True,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0005-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0005-development.json
+iteration-0006-development,development,20260905,mnist_compact,G8,50.713333,50.723333,0.00999999999999801,1.534298,1.492805,0.0270436381980554,0.4918032786885246,-186.8633001166316,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0006-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0006-development.json
+iteration-0006-development,development,20260905,mnist_wide,G5,46.656667,42.006667,-4.649999999999999,1.677872,1.749895,-0.04292520525999596,0.5,-186.8633001166316,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0006-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0006-development.json
+iteration-0006-development,development,20260905,fashion_compact,G8,46.366667,49.576667,3.210000000000001,1.497844,1.400574,0.06494000710354347,0.4918032786885246,-186.8633001166316,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0006-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0006-development.json
+iteration-0006-development,development,20260905,fashion_wide,G5,48.516667,49.08,0.5633330000000001,1.490304,1.466855,0.015734373657991962,0.5,-186.8633001166316,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0006-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0006-development.json
+iteration-0006-development,development,20260906,mnist_compact,G8,46.81,51.663333,4.853332999999999,1.58986,1.436337,0.09656384838916639,0.4918032786885246,-186.8633001166316,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0006-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0006-development.json
+iteration-0006-development,development,20260906,mnist_wide,G5,44.936667,40.84,-4.0966669999999965,1.665007,1.73617,-0.04274036085133581,0.5,-186.8633001166316,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0006-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0006-development.json
+iteration-0006-development,development,20260906,fashion_compact,G8,44.193333,48.753333,4.559999999999995,1.553097,1.375751,0.11418861796784104,0.4918032786885246,-186.8633001166316,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0006-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0006-development.json
+iteration-0006-development,development,20260906,fashion_wide,G5,48.37,46.946667,-1.4233329999999995,1.490657,1.508747,-0.012135588535793386,0.5,-186.8633001166316,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0006-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0006-development.json
+iteration-0007-development,development,20260905,mnist_compact,G8,50.713333,50.723333,0.00999999999999801,1.534298,1.492805,0.0270436381980554,0.4918032786885246,-391.33742460463645,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0007-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0007-development.json
+iteration-0007-development,development,20260905,mnist_wide,G5,46.656667,41.05,-5.606667000000002,1.677872,1.794261,-0.06936703157332626,0.5,-391.33742460463645,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0007-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0007-development.json
+iteration-0007-development,development,20260905,fashion_compact,G8,46.366667,49.576667,3.210000000000001,1.497844,1.400574,0.06494000710354347,0.4918032786885246,-391.33742460463645,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0007-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0007-development.json
+iteration-0007-development,development,20260905,fashion_wide,G5,48.516667,42.513333,-6.003333999999995,1.490304,1.615206,-0.08380974619943303,0.5,-391.33742460463645,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0007-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0007-development.json
+iteration-0007-development,development,20260906,mnist_compact,G8,46.81,51.663333,4.853332999999999,1.58986,1.436337,0.09656384838916639,0.4918032786885246,-391.33742460463645,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0007-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0007-development.json
+iteration-0007-development,development,20260906,mnist_wide,G5,44.936667,40.666667,-4.270000000000003,1.665007,1.764515,-0.059764313303187405,0.5,-391.33742460463645,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0007-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0007-development.json
+iteration-0007-development,development,20260906,fashion_compact,G8,44.193333,48.753333,4.559999999999995,1.553097,1.375751,0.11418861796784104,0.4918032786885246,-391.33742460463645,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0007-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0007-development.json
+iteration-0007-development,development,20260906,fashion_wide,G5,48.37,39.916667,-8.453333,1.490657,1.609595,-0.07978897895357565,0.5,-391.33742460463645,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0007-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0007-development.json
+iteration-0008-development,development,20260905,mnist_compact,G8,50.713333,50.723333,0.00999999999999801,1.534298,1.492805,0.0270436381980554,0.4918032786885246,-390.14811518493707,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0008-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0008-development.json
+iteration-0008-development,development,20260905,mnist_wide,G5,46.656667,41.14,-5.516666999999998,1.677872,1.748292,-0.041969828449369154,0.5,-390.14811518493707,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0008-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0008-development.json
+iteration-0008-development,development,20260905,fashion_compact,G8,46.366667,49.576667,3.210000000000001,1.497844,1.400574,0.06494000710354347,0.4918032786885246,-390.14811518493707,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0008-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0008-development.json
+iteration-0008-development,development,20260905,fashion_wide,G5,48.516667,45.726667,-2.789999999999999,1.490304,1.558163,-0.04553366293051612,0.5,-390.14811518493707,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0008-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0008-development.json
+iteration-0008-development,development,20260906,mnist_compact,G8,46.81,51.663333,4.853332999999999,1.58986,1.436337,0.09656384838916639,0.4918032786885246,-390.14811518493707,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0008-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0008-development.json
+iteration-0008-development,development,20260906,mnist_wide,G5,44.936667,39.596667,-5.340000000000003,1.665007,1.763671,-0.059257408527411654,0.5,-390.14811518493707,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0008-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0008-development.json
+iteration-0008-development,development,20260906,fashion_compact,G8,44.193333,48.753333,4.559999999999995,1.553097,1.375751,0.11418861796784104,0.4918032786885246,-390.14811518493707,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0008-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0008-development.json
+iteration-0008-development,development,20260906,fashion_wide,G5,48.37,43.246667,-5.123332999999995,1.490657,1.649349,-0.10645775654627461,0.5,-390.14811518493707,False,False,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/candidates/iteration-0008-development.json,.omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z/evaluations/iteration-0008-development.json
diff --git a/benchmark_results/pso_v7_heavy_cross_split.json b/benchmark_results/pso_v7_heavy_cross_split.json
new file mode 100644
index 0000000..d54abe7
--- /dev/null
+++ b/benchmark_results/pso_v7_heavy_cross_split.json
@@ -0,0 +1,1440 @@
+{
+ "protocol_version": "HEAVY-PSO-CROSS-SPLIT-PUBLISH 1.0.0",
+ "pso_version": "4.0.0",
+ "timestamp": "2026-09-04T07:38:14Z",
+ "mission_contract": {
+ "phase": "development",
+ "official_test_data_loaded": false,
+ "official_test_evaluations": 0,
+ "confirmation_executed": false,
+ "retained_policy": null
+ },
+ "official_test_data_loaded": false,
+ "official_test_evaluations": 0,
+ "confirmation_executed": false,
+ "retained_policy": null,
+ "verdict": {
+ "status": "NO_RETAINED_POLICY_NO_CONFIRMATION",
+ "retained_policy": null,
+ "confirmation_executed": false,
+ "official_test_data_loaded": false,
+ "official_test_evaluations": 0,
+ "best_observed_variant_id": "iteration-0005-development",
+ "best_observed_score": -185.61068572934795,
+ "description": "All 9 development candidates failed the frozen evaluator gates (specifically maximum accuracy regression and/or development wide CNN improvement). No candidate qualified for confirmation. Confirmation split 20260907 and official test data remained completely unexecuted and sealed."
+ },
+ "source_provenance": {
+ "source_dir": ".omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z",
+ "n_variants": 9,
+ "candidate_files": [
+ "iteration-0001-development.json",
+ "iteration-0002-development.json",
+ "iteration-0003-replica1-development.json",
+ "iteration-0003-replica2-development.json",
+ "iteration-0004-development.json",
+ "iteration-0005-development.json",
+ "iteration-0006-development.json",
+ "iteration-0007-development.json",
+ "iteration-0008-development.json"
+ ],
+ "evaluation_files": [
+ "iteration-0001-development.json",
+ "iteration-0002-development.json",
+ "iteration-0003-replica1-development.json",
+ "iteration-0003-replica2-development.json",
+ "iteration-0004-development.json",
+ "iteration-0005-development.json",
+ "iteration-0006-development.json",
+ "iteration-0007-development.json",
+ "iteration-0008-development.json"
+ ]
+ },
+ "cumulative_resources": {
+ "n_variants": 9,
+ "total_runs": 432,
+ "total_queries": 414720,
+ "total_sample_evaluations": 4147200000,
+ "official_test_evaluations": 0,
+ "best_observed_variant_id": "iteration-0005-development",
+ "wall_time_sec": 3162.9717,
+ "best_observed_score": -185.61068572934795
+ },
+ "total_runs": 432,
+ "total_wall_time_sec": 3162.9717,
+ "total_queries": 414720,
+ "total_sample_evaluations": 4147200000,
+ "variants": [
+ {
+ "variant_id": "iteration-0001-development",
+ "candidate_file": "iteration-0001-development.json",
+ "evaluation_file": "iteration-0001-development.json",
+ "phase": "development",
+ "candidate_config": {
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "projection_scope": "global",
+ "projection_seed_mode": "explicit",
+ "projection_seed": {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 592157828,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 189641451
+ },
+ "geometry_multiplier": 1.0,
+ "particles": 12,
+ "epochs": 80,
+ "subset_size": 10000
+ },
+ "score": -289.2921035434933,
+ "pass": false,
+ "development_pass": false,
+ "eligible_for_confirmation": false,
+ "failed_hard_gate_count": 4,
+ "failed_gates": [
+ "maximum_accuracy_regression_percentage_points_each_split_workload",
+ "maximum_nll_regression_fraction_each_split_workload",
+ "development_mnist_wide_improvement",
+ "confirmation_executed"
+ ],
+ "is_best_observed": false,
+ "summary_metrics": {
+ "development_cells": 8,
+ "confirmation_cells": 0,
+ "development_grand_mean_accuracy_gain_pp": 0.15333312499999963,
+ "development_grand_mean_nll_reduction_fraction": 0.005545633315067132,
+ "development_mnist_wide_accuracy_gain_pp": -0.3616670000000006,
+ "development_mnist_wide_nll_reduction_fraction": -0.024599621226530297
+ },
+ "state_ratios": {
+ "development": {
+ "mnist_compact": 0.4918032786885246,
+ "mnist_wide": 0.5,
+ "fashion_compact": 0.4918032786885246,
+ "fashion_wide": 0.5
+ },
+ "confirmation": null
+ },
+ "cell_metrics": [
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 50.713333,
+ "candidate_acc": 50.723333,
+ "baseline_nll": 1.534298,
+ "candidate_nll": 1.492805,
+ "acc_gain_pp": 0.00999999999999801,
+ "nll_reduction_fraction": 0.0270436381980554
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 46.656667,
+ "candidate_acc": 46.04,
+ "baseline_nll": 1.677872,
+ "candidate_nll": 1.675644,
+ "acc_gain_pp": -0.6166669999999996,
+ "nll_reduction_fraction": 0.0013278724479579603
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 46.366667,
+ "candidate_acc": 49.576667,
+ "baseline_nll": 1.497844,
+ "candidate_nll": 1.400574,
+ "acc_gain_pp": 3.210000000000001,
+ "nll_reduction_fraction": 0.06494000710354347
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.516667,
+ "candidate_acc": 45.01,
+ "baseline_nll": 1.490304,
+ "candidate_nll": 1.584923,
+ "acc_gain_pp": -3.506667,
+ "nll_reduction_fraction": -0.06348973095422142
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 46.81,
+ "candidate_acc": 51.663333,
+ "baseline_nll": 1.58986,
+ "candidate_nll": 1.436337,
+ "acc_gain_pp": 4.853332999999999,
+ "nll_reduction_fraction": 0.09656384838916639
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 44.936667,
+ "candidate_acc": 44.83,
+ "baseline_nll": 1.665007,
+ "candidate_nll": 1.749135,
+ "acc_gain_pp": -0.10666700000000162,
+ "nll_reduction_fraction": -0.050527114901018556
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 44.193333,
+ "candidate_acc": 48.753333,
+ "baseline_nll": 1.553097,
+ "candidate_nll": 1.375751,
+ "acc_gain_pp": 4.559999999999995,
+ "nll_reduction_fraction": 0.11418861796784104
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.37,
+ "candidate_acc": 41.193333,
+ "baseline_nll": 1.490657,
+ "candidate_nll": 1.707819,
+ "acc_gain_pp": -7.176666999999995,
+ "nll_reduction_fraction": -0.14568207173078723
+ }
+ ],
+ "resources": {
+ "runs": 48,
+ "queries": 46080,
+ "sample_evaluations": 460800000,
+ "wall_time_sec": 345.2731,
+ "official_test_evaluations": 0
+ }
+ },
+ {
+ "variant_id": "iteration-0002-development",
+ "candidate_file": "iteration-0002-development.json",
+ "evaluation_file": "iteration-0002-development.json",
+ "phase": "development",
+ "candidate_config": {
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "projection_scope": {
+ "mnist_compact": "global",
+ "mnist_wide": "balanced_global",
+ "fashion_compact": "global",
+ "fashion_wide": "balanced_global"
+ },
+ "projection_seed_mode": "explicit",
+ "projection_seed": {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 592157828,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 189641451
+ },
+ "geometry_multiplier": 1.0,
+ "particles": 12,
+ "epochs": 80,
+ "subset_size": 10000
+ },
+ "score": -186.3459040597986,
+ "pass": false,
+ "development_pass": false,
+ "eligible_for_confirmation": false,
+ "failed_hard_gate_count": 3,
+ "failed_gates": [
+ "maximum_accuracy_regression_percentage_points_each_split_workload",
+ "development_mnist_wide_improvement",
+ "confirmation_executed"
+ ],
+ "is_best_observed": false,
+ "summary_metrics": {
+ "development_cells": 8,
+ "confirmation_cells": 0,
+ "development_grand_mean_accuracy_gain_pp": 1.0591663750000002,
+ "development_grand_mean_nll_reduction_fraction": 0.025949295652013885,
+ "development_mnist_wide_accuracy_gain_pp": -0.6550004999999963,
+ "development_mnist_wide_nll_reduction_fraction": -0.03737641704538702
+ },
+ "state_ratios": {
+ "development": {
+ "mnist_compact": 0.4918032786885246,
+ "mnist_wide": 0.5,
+ "fashion_compact": 0.4918032786885246,
+ "fashion_wide": 0.5
+ },
+ "confirmation": null
+ },
+ "cell_metrics": [
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 50.713333,
+ "candidate_acc": 50.723333,
+ "baseline_nll": 1.534298,
+ "candidate_nll": 1.492805,
+ "acc_gain_pp": 0.00999999999999801,
+ "nll_reduction_fraction": 0.0270436381980554
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 46.656667,
+ "candidate_acc": 45.193333,
+ "baseline_nll": 1.677872,
+ "candidate_nll": 1.733563,
+ "acc_gain_pp": -1.4633339999999961,
+ "nll_reduction_fraction": -0.03319144726176963
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 46.366667,
+ "candidate_acc": 49.576667,
+ "baseline_nll": 1.497844,
+ "candidate_nll": 1.400574,
+ "acc_gain_pp": 3.210000000000001,
+ "nll_reduction_fraction": 0.06494000710354347
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.516667,
+ "candidate_acc": 47.223333,
+ "baseline_nll": 1.490304,
+ "candidate_nll": 1.536216,
+ "acc_gain_pp": -1.2933340000000015,
+ "nll_reduction_fraction": -0.03080713733573818
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 46.81,
+ "candidate_acc": 51.663333,
+ "baseline_nll": 1.58986,
+ "candidate_nll": 1.436337,
+ "acc_gain_pp": 4.853332999999999,
+ "nll_reduction_fraction": 0.09656384838916639
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 44.936667,
+ "candidate_acc": 45.09,
+ "baseline_nll": 1.665007,
+ "candidate_nll": 1.734207,
+ "acc_gain_pp": 0.1533330000000035,
+ "nll_reduction_fraction": -0.04156138682900441
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 44.193333,
+ "candidate_acc": 48.753333,
+ "baseline_nll": 1.553097,
+ "candidate_nll": 1.375751,
+ "acc_gain_pp": 4.559999999999995,
+ "nll_reduction_fraction": 0.11418861796784104
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.37,
+ "candidate_acc": 46.813333,
+ "baseline_nll": 1.490657,
+ "candidate_nll": 1.475127,
+ "acc_gain_pp": -1.5566669999999974,
+ "nll_reduction_fraction": 0.010418224984016995
+ }
+ ],
+ "resources": {
+ "runs": 48,
+ "queries": 46080,
+ "sample_evaluations": 460800000,
+ "wall_time_sec": 356.2424,
+ "official_test_evaluations": 0
+ }
+ },
+ {
+ "variant_id": "iteration-0003-replica1-development",
+ "candidate_file": "iteration-0003-replica1-development.json",
+ "evaluation_file": "iteration-0003-replica1-development.json",
+ "phase": "development",
+ "candidate_config": {
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "projection_scope": {
+ "mnist_compact": "global",
+ "mnist_wide": "balanced_global",
+ "fashion_compact": "global",
+ "fashion_wide": "balanced_global"
+ },
+ "projection_seed_mode": "explicit",
+ "projection_seed": {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 1170674349,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 1196992285
+ },
+ "geometry_multiplier": 1.0,
+ "particles": 12,
+ "epochs": 80,
+ "subset_size": 10000
+ },
+ "score": -287.7250973286179,
+ "pass": false,
+ "development_pass": false,
+ "eligible_for_confirmation": false,
+ "failed_hard_gate_count": 4,
+ "failed_gates": [
+ "maximum_accuracy_regression_percentage_points_each_split_workload",
+ "maximum_nll_regression_fraction_each_split_workload",
+ "development_mnist_wide_improvement",
+ "confirmation_executed"
+ ],
+ "is_best_observed": false,
+ "summary_metrics": {
+ "development_cells": 8,
+ "confirmation_cells": 0,
+ "development_grand_mean_accuracy_gain_pp": 0.5999997499999994,
+ "development_grand_mean_nll_reduction_fraction": 0.016749029213820897,
+ "development_mnist_wide_accuracy_gain_pp": -2.278334000000001,
+ "development_mnist_wide_nll_reduction_fraction": -0.029660445675769923
+ },
+ "state_ratios": {
+ "development": {
+ "mnist_compact": 0.4918032786885246,
+ "mnist_wide": 0.5,
+ "fashion_compact": 0.4918032786885246,
+ "fashion_wide": 0.5
+ },
+ "confirmation": null
+ },
+ "cell_metrics": [
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 50.713333,
+ "candidate_acc": 50.723333,
+ "baseline_nll": 1.534298,
+ "candidate_nll": 1.492805,
+ "acc_gain_pp": 0.00999999999999801,
+ "nll_reduction_fraction": 0.0270436381980554
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 46.656667,
+ "candidate_acc": 44.923333,
+ "baseline_nll": 1.677872,
+ "candidate_nll": 1.728906,
+ "acc_gain_pp": -1.7333339999999993,
+ "nll_reduction_fraction": -0.030415907768888223
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 46.366667,
+ "candidate_acc": 49.576667,
+ "baseline_nll": 1.497844,
+ "candidate_nll": 1.400574,
+ "acc_gain_pp": 3.210000000000001,
+ "nll_reduction_fraction": 0.06494000710354347
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.516667,
+ "candidate_acc": 47.176667,
+ "baseline_nll": 1.490304,
+ "candidate_nll": 1.56267,
+ "acc_gain_pp": -1.3399999999999963,
+ "nll_reduction_fraction": -0.048557878124194744
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 46.81,
+ "candidate_acc": 51.663333,
+ "baseline_nll": 1.58986,
+ "candidate_nll": 1.436337,
+ "acc_gain_pp": 4.853332999999999,
+ "nll_reduction_fraction": 0.09656384838916639
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 44.936667,
+ "candidate_acc": 42.113333,
+ "baseline_nll": 1.665007,
+ "candidate_nll": 1.713134,
+ "acc_gain_pp": -2.8233340000000027,
+ "nll_reduction_fraction": -0.028904983582651624
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 44.193333,
+ "candidate_acc": 48.753333,
+ "baseline_nll": 1.553097,
+ "candidate_nll": 1.375751,
+ "acc_gain_pp": 4.559999999999995,
+ "nll_reduction_fraction": 0.11418861796784104
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.37,
+ "candidate_acc": 46.433333,
+ "baseline_nll": 1.490657,
+ "candidate_nll": 1.581386,
+ "acc_gain_pp": -1.936667,
+ "nll_reduction_fraction": -0.06086510847230454
+ }
+ ],
+ "resources": {
+ "runs": 48,
+ "queries": 46080,
+ "sample_evaluations": 460800000,
+ "wall_time_sec": 333.3569,
+ "official_test_evaluations": 0
+ }
+ },
+ {
+ "variant_id": "iteration-0003-replica2-development",
+ "candidate_file": "iteration-0003-replica2-development.json",
+ "evaluation_file": "iteration-0003-replica2-development.json",
+ "phase": "development",
+ "candidate_config": {
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "projection_scope": {
+ "mnist_compact": "global",
+ "mnist_wide": "balanced_global",
+ "fashion_compact": "global",
+ "fashion_wide": "balanced_global"
+ },
+ "projection_seed_mode": "explicit",
+ "projection_seed": {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 1993337128,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 663492771
+ },
+ "geometry_multiplier": 1.0,
+ "particles": 12,
+ "epochs": 80,
+ "subset_size": 10000
+ },
+ "score": -286.97652369317115,
+ "pass": false,
+ "development_pass": false,
+ "eligible_for_confirmation": false,
+ "failed_hard_gate_count": 4,
+ "failed_gates": [
+ "maximum_accuracy_regression_percentage_points_each_split_workload",
+ "maximum_nll_regression_fraction_each_split_workload",
+ "development_mnist_wide_improvement",
+ "confirmation_executed"
+ ],
+ "is_best_observed": false,
+ "summary_metrics": {
+ "development_cells": 8,
+ "confirmation_cells": 0,
+ "development_grand_mean_accuracy_gain_pp": 0.7808331249999991,
+ "development_grand_mean_nll_reduction_fraction": 0.02242643181828852,
+ "development_mnist_wide_accuracy_gain_pp": -2.0133335000000017,
+ "development_mnist_wide_nll_reduction_fraction": -0.056248381748622824
+ },
+ "state_ratios": {
+ "development": {
+ "mnist_compact": 0.4918032786885246,
+ "mnist_wide": 0.5,
+ "fashion_compact": 0.4918032786885246,
+ "fashion_wide": 0.5
+ },
+ "confirmation": null
+ },
+ "cell_metrics": [
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 50.713333,
+ "candidate_acc": 50.723333,
+ "baseline_nll": 1.534298,
+ "candidate_nll": 1.492805,
+ "acc_gain_pp": 0.00999999999999801,
+ "nll_reduction_fraction": 0.0270436381980554
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 46.656667,
+ "candidate_acc": 46.01,
+ "baseline_nll": 1.677872,
+ "candidate_nll": 1.72888,
+ "acc_gain_pp": -0.6466670000000008,
+ "nll_reduction_fraction": -0.0304004119503752
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 46.366667,
+ "candidate_acc": 49.576667,
+ "baseline_nll": 1.497844,
+ "candidate_nll": 1.400574,
+ "acc_gain_pp": 3.210000000000001,
+ "nll_reduction_fraction": 0.06494000710354347
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.516667,
+ "candidate_acc": 48.613333,
+ "baseline_nll": 1.490304,
+ "candidate_nll": 1.48049,
+ "acc_gain_pp": 0.09666599999999903,
+ "nll_reduction_fraction": 0.006585233616765431
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 46.81,
+ "candidate_acc": 51.663333,
+ "baseline_nll": 1.58986,
+ "candidate_nll": 1.436337,
+ "acc_gain_pp": 4.853332999999999,
+ "nll_reduction_fraction": 0.09656384838916639
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 44.936667,
+ "candidate_acc": 41.556667,
+ "baseline_nll": 1.665007,
+ "candidate_nll": 1.801698,
+ "acc_gain_pp": -3.3800000000000026,
+ "nll_reduction_fraction": -0.08209635154687045
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 44.193333,
+ "candidate_acc": 48.753333,
+ "baseline_nll": 1.553097,
+ "candidate_nll": 1.375751,
+ "acc_gain_pp": 4.559999999999995,
+ "nll_reduction_fraction": 0.11418861796784104
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.37,
+ "candidate_acc": 45.913333,
+ "baseline_nll": 1.490657,
+ "candidate_nll": 1.516614,
+ "acc_gain_pp": -2.456666999999996,
+ "nll_reduction_fraction": -0.017413127231817923
+ }
+ ],
+ "resources": {
+ "runs": 48,
+ "queries": 46080,
+ "sample_evaluations": 460800000,
+ "wall_time_sec": 340.8067,
+ "official_test_evaluations": 0
+ }
+ },
+ {
+ "variant_id": "iteration-0004-development",
+ "candidate_file": "iteration-0004-development.json",
+ "evaluation_file": "iteration-0004-development.json",
+ "phase": "development",
+ "candidate_config": {
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "projection_scope": {
+ "mnist_compact": "global",
+ "mnist_wide": "two_hash_global",
+ "fashion_compact": "global",
+ "fashion_wide": "two_hash_global"
+ },
+ "projection_seed_mode": "explicit",
+ "projection_seed": {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 592157828,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 189641451
+ },
+ "geometry_multiplier": 1.0,
+ "particles": 12,
+ "epochs": 80,
+ "subset_size": 10000
+ },
+ "score": -390.14004501856266,
+ "pass": false,
+ "development_pass": false,
+ "eligible_for_confirmation": false,
+ "failed_hard_gate_count": 5,
+ "failed_gates": [
+ "maximum_accuracy_regression_percentage_points_each_split_workload",
+ "maximum_nll_regression_fraction_each_split_workload",
+ "development_grand_mean_accuracy_gain_minimum_pp",
+ "development_mnist_wide_improvement",
+ "confirmation_executed"
+ ],
+ "is_best_observed": false,
+ "summary_metrics": {
+ "development_cells": 8,
+ "confirmation_cells": 0,
+ "development_grand_mean_accuracy_gain_pp": -0.4275001249999999,
+ "development_grand_mean_nll_reduction_fraction": 0.002874551064373243,
+ "development_mnist_wide_accuracy_gain_pp": -3.941666999999999,
+ "development_mnist_wide_nll_reduction_fraction": -0.05273851995206307
+ },
+ "state_ratios": {
+ "development": {
+ "mnist_compact": 0.4918032786885246,
+ "mnist_wide": 0.5,
+ "fashion_compact": 0.4918032786885246,
+ "fashion_wide": 0.5
+ },
+ "confirmation": null
+ },
+ "cell_metrics": [
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 50.713333,
+ "candidate_acc": 50.723333,
+ "baseline_nll": 1.534298,
+ "candidate_nll": 1.492805,
+ "acc_gain_pp": 0.00999999999999801,
+ "nll_reduction_fraction": 0.0270436381980554
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 46.656667,
+ "candidate_acc": 44.763333,
+ "baseline_nll": 1.677872,
+ "candidate_nll": 1.698999,
+ "acc_gain_pp": -1.8933339999999959,
+ "nll_reduction_fraction": -0.012591544527830428
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 46.366667,
+ "candidate_acc": 49.576667,
+ "baseline_nll": 1.497844,
+ "candidate_nll": 1.400574,
+ "acc_gain_pp": 3.210000000000001,
+ "nll_reduction_fraction": 0.06494000710354347
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.516667,
+ "candidate_acc": 44.816667,
+ "baseline_nll": 1.490304,
+ "candidate_nll": 1.582588,
+ "acc_gain_pp": -3.6999999999999957,
+ "nll_reduction_fraction": -0.06192293652838617
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 46.81,
+ "candidate_acc": 51.663333,
+ "baseline_nll": 1.58986,
+ "candidate_nll": 1.436337,
+ "acc_gain_pp": 4.853332999999999,
+ "nll_reduction_fraction": 0.09656384838916639
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 44.936667,
+ "candidate_acc": 38.946667,
+ "baseline_nll": 1.665007,
+ "candidate_nll": 1.819662,
+ "acc_gain_pp": -5.990000000000002,
+ "nll_reduction_fraction": -0.09288549537629572
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 44.193333,
+ "candidate_acc": 48.753333,
+ "baseline_nll": 1.553097,
+ "candidate_nll": 1.375751,
+ "acc_gain_pp": 4.559999999999995,
+ "nll_reduction_fraction": 0.11418861796784104
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.37,
+ "candidate_acc": 43.9,
+ "baseline_nll": 1.490657,
+ "candidate_nll": 1.658117,
+ "acc_gain_pp": -4.469999999999999,
+ "nll_reduction_fraction": -0.11233972671110803
+ }
+ ],
+ "resources": {
+ "runs": 48,
+ "queries": 46080,
+ "sample_evaluations": 460800000,
+ "wall_time_sec": 341.0849,
+ "official_test_evaluations": 0
+ }
+ },
+ {
+ "variant_id": "iteration-0005-development",
+ "candidate_file": "iteration-0005-development.json",
+ "evaluation_file": "iteration-0005-development.json",
+ "phase": "development",
+ "candidate_config": {
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "projection_scope": {
+ "mnist_compact": "global",
+ "mnist_wide": "largest_tensor_hash",
+ "fashion_compact": "global",
+ "fashion_wide": "largest_tensor_hash"
+ },
+ "projection_seed_mode": "explicit",
+ "projection_seed": {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 592157828,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 189641451
+ },
+ "geometry_multiplier": 1.0,
+ "particles": 12,
+ "epochs": 80,
+ "subset_size": 10000
+ },
+ "score": -185.61068572934795,
+ "pass": false,
+ "development_pass": false,
+ "eligible_for_confirmation": false,
+ "failed_hard_gate_count": 3,
+ "failed_gates": [
+ "maximum_accuracy_regression_percentage_points_each_split_workload",
+ "development_mnist_wide_improvement",
+ "confirmation_executed"
+ ],
+ "is_best_observed": true,
+ "summary_metrics": {
+ "development_cells": 8,
+ "confirmation_cells": 0,
+ "development_grand_mean_accuracy_gain_pp": 0.43999974999999925,
+ "development_grand_mean_nll_reduction_fraction": 0.03949314520652041,
+ "development_mnist_wide_accuracy_gain_pp": -2.6633340000000025,
+ "development_mnist_wide_nll_reduction_fraction": -0.02187403189962274
+ },
+ "state_ratios": {
+ "development": {
+ "mnist_compact": 0.4918032786885246,
+ "mnist_wide": 0.5,
+ "fashion_compact": 0.4918032786885246,
+ "fashion_wide": 0.5
+ },
+ "confirmation": null
+ },
+ "cell_metrics": [
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 50.713333,
+ "candidate_acc": 50.723333,
+ "baseline_nll": 1.534298,
+ "candidate_nll": 1.492805,
+ "acc_gain_pp": 0.00999999999999801,
+ "nll_reduction_fraction": 0.0270436381980554
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 46.656667,
+ "candidate_acc": 43.723333,
+ "baseline_nll": 1.677872,
+ "candidate_nll": 1.675155,
+ "acc_gain_pp": -2.933334000000002,
+ "nll_reduction_fraction": 0.0016193130346057866
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 46.366667,
+ "candidate_acc": 49.576667,
+ "baseline_nll": 1.497844,
+ "candidate_nll": 1.400574,
+ "acc_gain_pp": 3.210000000000001,
+ "nll_reduction_fraction": 0.06494000710354347
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.516667,
+ "candidate_acc": 45.45,
+ "baseline_nll": 1.490304,
+ "candidate_nll": 1.441667,
+ "acc_gain_pp": -3.0666669999999954,
+ "nll_reduction_fraction": 0.03263562333591002
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 46.81,
+ "candidate_acc": 51.663333,
+ "baseline_nll": 1.58986,
+ "candidate_nll": 1.436337,
+ "acc_gain_pp": 4.853332999999999,
+ "nll_reduction_fraction": 0.09656384838916639
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 44.936667,
+ "candidate_acc": 42.543333,
+ "baseline_nll": 1.665007,
+ "candidate_nll": 1.740544,
+ "acc_gain_pp": -2.393334000000003,
+ "nll_reduction_fraction": -0.04536737683385127
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 44.193333,
+ "candidate_acc": 48.753333,
+ "baseline_nll": 1.553097,
+ "candidate_nll": 1.375751,
+ "acc_gain_pp": 4.559999999999995,
+ "nll_reduction_fraction": 0.11418861796784104
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.37,
+ "candidate_acc": 47.65,
+ "baseline_nll": 1.490657,
+ "candidate_nll": 1.454402,
+ "acc_gain_pp": -0.7199999999999989,
+ "nll_reduction_fraction": 0.02432149045689245
+ }
+ ],
+ "resources": {
+ "runs": 48,
+ "queries": 46080,
+ "sample_evaluations": 460800000,
+ "wall_time_sec": 342.0566,
+ "official_test_evaluations": 0
+ }
+ },
+ {
+ "variant_id": "iteration-0006-development",
+ "candidate_file": "iteration-0006-development.json",
+ "evaluation_file": "iteration-0006-development.json",
+ "phase": "development",
+ "candidate_config": {
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "projection_scope": {
+ "mnist_compact": "global",
+ "mnist_wide": "largest_tensor_row_hash",
+ "fashion_compact": "global",
+ "fashion_wide": "largest_tensor_row_hash"
+ },
+ "projection_seed_mode": "explicit",
+ "projection_seed": {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 592157828,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 189641451
+ },
+ "geometry_multiplier": 1.0,
+ "particles": 12,
+ "epochs": 80,
+ "subset_size": 10000
+ },
+ "score": -186.8633001166316,
+ "pass": false,
+ "development_pass": false,
+ "eligible_for_confirmation": false,
+ "failed_hard_gate_count": 3,
+ "failed_gates": [
+ "maximum_accuracy_regression_percentage_points_each_split_workload",
+ "development_mnist_wide_improvement",
+ "confirmation_executed"
+ ],
+ "is_best_observed": false,
+ "summary_metrics": {
+ "development_cells": 8,
+ "confirmation_cells": 0,
+ "development_grand_mean_accuracy_gain_pp": 0.37833324999999984,
+ "development_grand_mean_nll_reduction_fraction": 0.027583666333684136,
+ "development_mnist_wide_accuracy_gain_pp": -4.3733334999999975,
+ "development_mnist_wide_nll_reduction_fraction": -0.04283278305566589
+ },
+ "state_ratios": {
+ "development": {
+ "mnist_compact": 0.4918032786885246,
+ "mnist_wide": 0.5,
+ "fashion_compact": 0.4918032786885246,
+ "fashion_wide": 0.5
+ },
+ "confirmation": null
+ },
+ "cell_metrics": [
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 50.713333,
+ "candidate_acc": 50.723333,
+ "baseline_nll": 1.534298,
+ "candidate_nll": 1.492805,
+ "acc_gain_pp": 0.00999999999999801,
+ "nll_reduction_fraction": 0.0270436381980554
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 46.656667,
+ "candidate_acc": 42.006667,
+ "baseline_nll": 1.677872,
+ "candidate_nll": 1.749895,
+ "acc_gain_pp": -4.649999999999999,
+ "nll_reduction_fraction": -0.04292520525999596
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 46.366667,
+ "candidate_acc": 49.576667,
+ "baseline_nll": 1.497844,
+ "candidate_nll": 1.400574,
+ "acc_gain_pp": 3.210000000000001,
+ "nll_reduction_fraction": 0.06494000710354347
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.516667,
+ "candidate_acc": 49.08,
+ "baseline_nll": 1.490304,
+ "candidate_nll": 1.466855,
+ "acc_gain_pp": 0.5633330000000001,
+ "nll_reduction_fraction": 0.015734373657991962
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 46.81,
+ "candidate_acc": 51.663333,
+ "baseline_nll": 1.58986,
+ "candidate_nll": 1.436337,
+ "acc_gain_pp": 4.853332999999999,
+ "nll_reduction_fraction": 0.09656384838916639
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 44.936667,
+ "candidate_acc": 40.84,
+ "baseline_nll": 1.665007,
+ "candidate_nll": 1.73617,
+ "acc_gain_pp": -4.0966669999999965,
+ "nll_reduction_fraction": -0.04274036085133581
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 44.193333,
+ "candidate_acc": 48.753333,
+ "baseline_nll": 1.553097,
+ "candidate_nll": 1.375751,
+ "acc_gain_pp": 4.559999999999995,
+ "nll_reduction_fraction": 0.11418861796784104
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.37,
+ "candidate_acc": 46.946667,
+ "baseline_nll": 1.490657,
+ "candidate_nll": 1.508747,
+ "acc_gain_pp": -1.4233329999999995,
+ "nll_reduction_fraction": -0.012135588535793386
+ }
+ ],
+ "resources": {
+ "runs": 48,
+ "queries": 46080,
+ "sample_evaluations": 460800000,
+ "wall_time_sec": 371.7913,
+ "official_test_evaluations": 0
+ }
+ },
+ {
+ "variant_id": "iteration-0007-development",
+ "candidate_file": "iteration-0007-development.json",
+ "evaluation_file": "iteration-0007-development.json",
+ "phase": "development",
+ "candidate_config": {
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "projection_scope": {
+ "mnist_compact": "global",
+ "mnist_wide": "adjacent_pair",
+ "fashion_compact": "global",
+ "fashion_wide": "adjacent_pair"
+ },
+ "projection_seed_mode": "explicit",
+ "projection_seed": {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 592157828,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 189641451
+ },
+ "geometry_multiplier": 1.0,
+ "particles": 12,
+ "epochs": 80,
+ "subset_size": 10000
+ },
+ "score": -391.33742460463645,
+ "pass": false,
+ "development_pass": false,
+ "eligible_for_confirmation": false,
+ "failed_hard_gate_count": 5,
+ "failed_gates": [
+ "maximum_accuracy_regression_percentage_points_each_split_workload",
+ "maximum_nll_regression_fraction_each_split_workload",
+ "development_grand_mean_accuracy_gain_minimum_pp",
+ "development_mnist_wide_improvement",
+ "confirmation_executed"
+ ],
+ "is_best_observed": false,
+ "summary_metrics": {
+ "development_cells": 8,
+ "confirmation_cells": 0,
+ "development_grand_mean_accuracy_gain_pp": -1.462500125000001,
+ "development_grand_mean_nll_reduction_fraction": 0.0012507552036354948,
+ "development_mnist_wide_accuracy_gain_pp": -4.938333500000002,
+ "development_mnist_wide_nll_reduction_fraction": -0.06456567243825684
+ },
+ "state_ratios": {
+ "development": {
+ "mnist_compact": 0.4918032786885246,
+ "mnist_wide": 0.5,
+ "fashion_compact": 0.4918032786885246,
+ "fashion_wide": 0.5
+ },
+ "confirmation": null
+ },
+ "cell_metrics": [
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 50.713333,
+ "candidate_acc": 50.723333,
+ "baseline_nll": 1.534298,
+ "candidate_nll": 1.492805,
+ "acc_gain_pp": 0.00999999999999801,
+ "nll_reduction_fraction": 0.0270436381980554
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 46.656667,
+ "candidate_acc": 41.05,
+ "baseline_nll": 1.677872,
+ "candidate_nll": 1.794261,
+ "acc_gain_pp": -5.606667000000002,
+ "nll_reduction_fraction": -0.06936703157332626
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 46.366667,
+ "candidate_acc": 49.576667,
+ "baseline_nll": 1.497844,
+ "candidate_nll": 1.400574,
+ "acc_gain_pp": 3.210000000000001,
+ "nll_reduction_fraction": 0.06494000710354347
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.516667,
+ "candidate_acc": 42.513333,
+ "baseline_nll": 1.490304,
+ "candidate_nll": 1.615206,
+ "acc_gain_pp": -6.003333999999995,
+ "nll_reduction_fraction": -0.08380974619943303
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 46.81,
+ "candidate_acc": 51.663333,
+ "baseline_nll": 1.58986,
+ "candidate_nll": 1.436337,
+ "acc_gain_pp": 4.853332999999999,
+ "nll_reduction_fraction": 0.09656384838916639
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 44.936667,
+ "candidate_acc": 40.666667,
+ "baseline_nll": 1.665007,
+ "candidate_nll": 1.764515,
+ "acc_gain_pp": -4.270000000000003,
+ "nll_reduction_fraction": -0.059764313303187405
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 44.193333,
+ "candidate_acc": 48.753333,
+ "baseline_nll": 1.553097,
+ "candidate_nll": 1.375751,
+ "acc_gain_pp": 4.559999999999995,
+ "nll_reduction_fraction": 0.11418861796784104
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.37,
+ "candidate_acc": 39.916667,
+ "baseline_nll": 1.490657,
+ "candidate_nll": 1.609595,
+ "acc_gain_pp": -8.453333,
+ "nll_reduction_fraction": -0.07978897895357565
+ }
+ ],
+ "resources": {
+ "runs": 48,
+ "queries": 46080,
+ "sample_evaluations": 460800000,
+ "wall_time_sec": 356.7982,
+ "official_test_evaluations": 0
+ }
+ },
+ {
+ "variant_id": "iteration-0008-development",
+ "candidate_file": "iteration-0008-development.json",
+ "evaluation_file": "iteration-0008-development.json",
+ "phase": "development",
+ "candidate_config": {
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "projection_scope": {
+ "mnist_compact": "global",
+ "mnist_wide": "adjacent_difference",
+ "fashion_compact": "global",
+ "fashion_wide": "adjacent_difference"
+ },
+ "projection_seed_mode": "explicit",
+ "projection_seed": {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 592157828,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 189641451
+ },
+ "geometry_multiplier": 1.0,
+ "particles": 12,
+ "epochs": 80,
+ "subset_size": 10000
+ },
+ "score": -390.14811518493707,
+ "pass": false,
+ "development_pass": false,
+ "eligible_for_confirmation": false,
+ "failed_hard_gate_count": 5,
+ "failed_gates": [
+ "maximum_accuracy_regression_percentage_points_each_split_workload",
+ "maximum_nll_regression_fraction_each_split_workload",
+ "development_grand_mean_accuracy_gain_minimum_pp",
+ "development_mnist_wide_improvement",
+ "confirmation_executed"
+ ],
+ "is_best_observed": false,
+ "summary_metrics": {
+ "development_cells": 8,
+ "confirmation_cells": 0,
+ "development_grand_mean_accuracy_gain_pp": -0.7670833750000003,
+ "development_grand_mean_nll_reduction_fraction": 0.006189681900629345,
+ "development_mnist_wide_accuracy_gain_pp": -5.428333500000001,
+ "development_mnist_wide_nll_reduction_fraction": -0.050613618488390404
+ },
+ "state_ratios": {
+ "development": {
+ "mnist_compact": 0.4918032786885246,
+ "mnist_wide": 0.5,
+ "fashion_compact": 0.4918032786885246,
+ "fashion_wide": 0.5
+ },
+ "confirmation": null
+ },
+ "cell_metrics": [
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 50.713333,
+ "candidate_acc": 50.723333,
+ "baseline_nll": 1.534298,
+ "candidate_nll": 1.492805,
+ "acc_gain_pp": 0.00999999999999801,
+ "nll_reduction_fraction": 0.0270436381980554
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 46.656667,
+ "candidate_acc": 41.14,
+ "baseline_nll": 1.677872,
+ "candidate_nll": 1.748292,
+ "acc_gain_pp": -5.516666999999998,
+ "nll_reduction_fraction": -0.041969828449369154
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 46.366667,
+ "candidate_acc": 49.576667,
+ "baseline_nll": 1.497844,
+ "candidate_nll": 1.400574,
+ "acc_gain_pp": 3.210000000000001,
+ "nll_reduction_fraction": 0.06494000710354347
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260905,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.516667,
+ "candidate_acc": 45.726667,
+ "baseline_nll": 1.490304,
+ "candidate_nll": 1.558163,
+ "acc_gain_pp": -2.789999999999999,
+ "nll_reduction_fraction": -0.04553366293051612
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_compact",
+ "baseline_acc": 46.81,
+ "candidate_acc": 51.663333,
+ "baseline_nll": 1.58986,
+ "candidate_nll": 1.436337,
+ "acc_gain_pp": 4.853332999999999,
+ "nll_reduction_fraction": 0.09656384838916639
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "mnist_wide",
+ "baseline_acc": 44.936667,
+ "candidate_acc": 39.596667,
+ "baseline_nll": 1.665007,
+ "candidate_nll": 1.763671,
+ "acc_gain_pp": -5.340000000000003,
+ "nll_reduction_fraction": -0.059257408527411654
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_compact",
+ "baseline_acc": 44.193333,
+ "candidate_acc": 48.753333,
+ "baseline_nll": 1.553097,
+ "candidate_nll": 1.375751,
+ "acc_gain_pp": 4.559999999999995,
+ "nll_reduction_fraction": 0.11418861796784104
+ },
+ {
+ "phase": "development",
+ "split_seed": 20260906,
+ "workload_id": "fashion_wide",
+ "baseline_acc": 48.37,
+ "candidate_acc": 43.246667,
+ "baseline_nll": 1.490657,
+ "candidate_nll": 1.649349,
+ "acc_gain_pp": -5.123332999999995,
+ "nll_reduction_fraction": -0.10645775654627461
+ }
+ ],
+ "resources": {
+ "runs": 48,
+ "queries": 46080,
+ "sample_evaluations": 460800000,
+ "wall_time_sec": 375.5616,
+ "official_test_evaluations": 0
+ }
+ }
+ ]
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v8_post_training_ensemble.csv b/benchmark_results/pso_v8_post_training_ensemble.csv
new file mode 100644
index 0000000..4b6be19
--- /dev/null
+++ b/benchmark_results/pso_v8_post_training_ensemble.csv
@@ -0,0 +1,29 @@
+Workload,Phase,Method,Accuracy,NLL,Brier,ECE,Margin,WallTimeSeconds,ParameterMultiplier,InferenceMultiplier
+mnist,validation,reference_single_10e,98.2300,0.060105,0.027982,0.003458,0.969858,0.0000,1.0,1.0
+mnist,validation,best_single_10e,98.2900,0.054029,0.025526,0.002795,0.971419,0.0000,1.0,1.0
+mnist,validation,single_50e,98.5200,0.073988,0.024922,0.009463,0.989411,0.0000,1.0,1.0
+mnist,validation,uniform_ensemble,98.6300,0.046385,0.021527,0.006228,0.965339,0.0000,5.0,5.0
+mnist,validation,uniform_temperature,98.6300,0.045355,0.021099,0.002518,0.972273,0.0412,5.0,5.0
+mnist,validation,slsqp_weights,98.6000,0.045902,0.021307,0.005994,0.965581,0.0097,5.0,5.0
+mnist,validation,pso_weights,98.6100,0.045902,0.021307,0.005893,0.965582,1.8925,5.0,5.0
+mnist,official_test,reference_single_10e,98.4700,0.044991,0.022366,0.003516,0.970575,0.0000,1.0,1.0
+mnist,official_test,best_single_10e,98.5500,0.044944,0.022052,0.002515,0.974650,0.0000,1.0,1.0
+mnist,official_test,single_50e,98.6000,0.062102,0.022912,0.008283,0.988829,0.0000,1.0,1.0
+mnist,official_test,uniform_ensemble,98.8600,0.036184,0.018010,0.006311,0.968415,0.0000,5.0,5.0
+mnist,official_test,uniform_temperature,98.8600,0.034129,0.017658,0.003340,0.974869,0.0000,5.0,5.0
+mnist,official_test,slsqp_weights,98.8300,0.036179,0.017989,0.005818,0.969195,0.0000,5.0,5.0
+mnist,official_test,pso_weights,98.8300,0.036178,0.017989,0.005817,0.969196,0.0000,5.0,5.0
+fashion_mnist,validation,reference_single_10e,89.4700,0.303799,0.150671,0.012197,0.808017,0.0000,1.0,1.0
+fashion_mnist,validation,best_single_10e,89.4700,0.303799,0.150671,0.012197,0.808017,0.0000,1.0,1.0
+fashion_mnist,validation,single_50e,90.3200,0.289660,0.142115,0.024556,0.869484,0.0000,1.0,1.0
+fashion_mnist,validation,uniform_ensemble,90.2800,0.286751,0.142881,0.023702,0.795588,0.0000,5.0,5.0
+fashion_mnist,validation,uniform_temperature,90.2800,0.285048,0.141557,0.011886,0.814383,0.0414,5.0,5.0
+fashion_mnist,validation,slsqp_weights,90.4200,0.285338,0.142289,0.023705,0.798413,0.0104,5.0,5.0
+fashion_mnist,validation,pso_weights,90.4200,0.285338,0.142289,0.023661,0.798397,1.8963,5.0,5.0
+fashion_mnist,official_test,reference_single_10e,88.9000,0.314516,0.161465,0.005320,0.805307,0.0000,1.0,1.0
+fashion_mnist,official_test,best_single_10e,88.9000,0.314516,0.161465,0.005320,0.805307,0.0000,1.0,1.0
+fashion_mnist,official_test,single_50e,89.9300,0.302348,0.148289,0.026401,0.865728,0.0000,1.0,1.0
+fashion_mnist,official_test,uniform_ensemble,89.6500,0.293522,0.151400,0.019111,0.791698,0.0000,5.0,5.0
+fashion_mnist,official_test,uniform_temperature,89.6500,0.291996,0.150581,0.007597,0.810594,0.0000,5.0,5.0
+fashion_mnist,official_test,slsqp_weights,89.5400,0.291696,0.150558,0.017186,0.794293,0.0000,5.0,5.0
+fashion_mnist,official_test,pso_weights,89.5400,0.291700,0.150559,0.017378,0.794274,0.0000,5.0,5.0
diff --git a/benchmark_results/pso_v8_post_training_ensemble.json b/benchmark_results/pso_v8_post_training_ensemble.json
new file mode 100644
index 0000000..95e95b9
--- /dev/null
+++ b/benchmark_results/pso_v8_post_training_ensemble.json
@@ -0,0 +1,683 @@
+{
+ "protocol_version": "POST-TRAINING-PSO-ENSEMBLE 1.1.0",
+ "config": {
+ "iteration": 1,
+ "archived_iteration0_reference": {
+ "epochs": 50,
+ "queries_per_seed": 1500,
+ "sample_evaluations_per_seed": 15000000,
+ "reason": "wall_time_ratio_gate_exceeded"
+ },
+ "datasets": [
+ "mnist",
+ "fashion_mnist"
+ ],
+ "split_seed": 20260904,
+ "search_samples": 50000,
+ "validation_samples": 10000,
+ "pool_seeds": [
+ 201,
+ 202,
+ 203,
+ 204,
+ 205
+ ],
+ "reference_single_seed": 201,
+ "equal_budget_single_epochs": 50,
+ "adam_lr": 0.001,
+ "adam_batch_size": 256,
+ "pso": {
+ "method": "constriction",
+ "evaluation": "full",
+ "renewal": "loss",
+ "particles": 30,
+ "epochs": 30,
+ "swarm_seeds": [
+ 301,
+ 302,
+ 303
+ ],
+ "queries_per_seed": 900,
+ "sample_evaluations_per_seed": 9000000,
+ "particle_bounds": [
+ -4.0,
+ 4.0
+ ],
+ "boundary_strategy": "reflect",
+ "velocity_limit_ratio": 0.1,
+ "initial_position_noise": 0.0
+ },
+ "device": "mps"
+ },
+ "workloads": {
+ "mnist": {
+ "provenance": {
+ "dataset_name": "MNIST",
+ "split_seed": 20260904,
+ "search_samples": 50000,
+ "validation_samples": 10000,
+ "normalization": {
+ "mean": 0.1307128667831421,
+ "std": 0.3081730008125305
+ },
+ "data_fingerprint": "861b07884cffefb9",
+ "split_fingerprint": "258b42dde7da6324"
+ },
+ "training": {
+ "architecture": "CompactCNN",
+ "parameters": 9098,
+ "pool_seeds": [
+ 201,
+ 202,
+ 203,
+ 204,
+ 205
+ ],
+ "pool_epochs_each": 10,
+ "adam_pool_epochs": 50,
+ "adam_lr": 0.001,
+ "adam_batch_size": 256,
+ "adam_pool_wall_time_seconds": 22.098886500985827,
+ "single_50e_epochs": 50,
+ "single_50e_wall_time_seconds": 22.06671220799035,
+ "model_fingerprints": {
+ "201": "046605462c4fc294",
+ "single_50e": "53ff4c61db919c1e",
+ "202": "cd3150799e0db43e",
+ "203": "1feb0f4dd7630ec2",
+ "204": "9dc0606cd8076cb2",
+ "205": "5bc16dc8f86cc869"
+ }
+ },
+ "validation_cache": {
+ "valid": true,
+ "pool_forward_passes": 5,
+ "long_single_forward_passes": 1,
+ "base_cnn_forward_passes_during_optimization": 0,
+ "shape": [
+ 5,
+ 10000,
+ 10
+ ],
+ "memory_bytes": 2400000,
+ "wall_time_seconds": 0.09316845799912699
+ },
+ "validation": {
+ "methods": {
+ "reference_single_10e": {
+ "accuracy": 98.23,
+ "nll": 0.060105,
+ "brier": 0.027982,
+ "ece": 0.003458,
+ "margin": 0.969858
+ },
+ "best_single_10e": {
+ "accuracy": 98.29,
+ "nll": 0.054029,
+ "brier": 0.025526,
+ "ece": 0.002795,
+ "margin": 0.971419,
+ "selected_seed": 205
+ },
+ "single_50e": {
+ "accuracy": 98.52,
+ "nll": 0.073988,
+ "brier": 0.024922,
+ "ece": 0.009463,
+ "margin": 0.989411
+ },
+ "uniform_ensemble": {
+ "accuracy": 98.63,
+ "nll": 0.046385,
+ "brier": 0.021527,
+ "ece": 0.006228,
+ "margin": 0.965339
+ },
+ "uniform_temperature": {
+ "fitted_temperature": 0.854572,
+ "wall_time_seconds": 0.04119049999280833,
+ "evaluations": 23,
+ "metrics": {
+ "accuracy": 98.63,
+ "nll": 0.045355,
+ "brier": 0.021099,
+ "ece": 0.002518,
+ "margin": 0.972273
+ }
+ },
+ "slsqp_weights": {
+ "weights": [
+ 0.05767137130295378,
+ 0.2585033373652759,
+ 0.10841769748910005,
+ 0.25254869759276993,
+ 0.3228588962499004
+ ],
+ "evaluations": 23,
+ "wall_time_seconds": 0.009686834004241973,
+ "success": true,
+ "message": "Optimization terminated successfully",
+ "metrics": {
+ "accuracy": 98.6,
+ "nll": 0.045902,
+ "brier": 0.021307,
+ "ece": 0.005994,
+ "margin": 0.965581
+ }
+ },
+ "pso_weights": {
+ "per_seed_runs": [
+ {
+ "seed": 301,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "wall_time_seconds": 1.8924723340023775,
+ "metrics": {
+ "accuracy": 98.61,
+ "nll": 0.045902,
+ "brier": 0.021307,
+ "ece": 0.005893,
+ "margin": 0.965582
+ },
+ "weights": [
+ 0.057233214378356934,
+ 0.2590548098087311,
+ 0.10862385481595993,
+ 0.25228697061538696,
+ 0.3228012025356293
+ ]
+ },
+ {
+ "seed": 302,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "wall_time_seconds": 1.7105932499980554,
+ "metrics": {
+ "accuracy": 98.6,
+ "nll": 0.045902,
+ "brier": 0.021306,
+ "ece": 0.006183,
+ "margin": 0.965578
+ },
+ "weights": [
+ 0.058317527174949646,
+ 0.25828817486763,
+ 0.10924994200468063,
+ 0.252756267786026,
+ 0.3213881254196167
+ ]
+ },
+ {
+ "seed": 303,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "wall_time_seconds": 1.8959678749961313,
+ "metrics": {
+ "accuracy": 98.61,
+ "nll": 0.045902,
+ "brier": 0.021307,
+ "ece": 0.005833,
+ "margin": 0.965583
+ },
+ "weights": [
+ 0.056311722844839096,
+ 0.2563577890396118,
+ 0.11076968908309937,
+ 0.25350210070610046,
+ 0.3230587840080261
+ ]
+ }
+ ],
+ "selected_seed": 301,
+ "selected_weights": [
+ 0.057233214378356934,
+ 0.2590548098087311,
+ 0.10862385481595993,
+ 0.25228697061538696,
+ 0.3228012025356293
+ ],
+ "metrics": {
+ "accuracy": 98.61,
+ "nll": 0.045902,
+ "brier": 0.021307,
+ "ece": 0.005893,
+ "margin": 0.965582
+ },
+ "queries_per_seed": 900,
+ "sample_evaluations_per_seed": 9000000,
+ "total_queries": 2700,
+ "total_sample_evaluations": 27000000,
+ "median_one_seed_wall_time_seconds": 1.8924723340023775,
+ "total_wall_time_seconds": 5.499033458996564
+ }
+ }
+ },
+ "official_test_data_loaded_before_freeze": false,
+ "official_test_evaluations_before_freeze": 0,
+ "confirmation": {
+ "official_test_data_loaded": true,
+ "test_cache_counts": {
+ "dataset_loads": 1,
+ "pool_forward_passes": 5,
+ "long_single_forward_passes": 1,
+ "base_cnn_forward_passes_during_optimization": 0,
+ "memory_bytes": 2400000,
+ "wall_time_seconds": 0.11975424998672679
+ },
+ "frozen_methods": {
+ "selected_pso_seed": 301,
+ "selected_pso_weights": [
+ 0.057233214378356934,
+ 0.2590548098087311,
+ 0.10862385481595993,
+ 0.25228697061538696,
+ 0.3228012025356293
+ ],
+ "slsqp_weights": [
+ 0.05767137130295378,
+ 0.2585033373652759,
+ 0.10841769748910005,
+ 0.25254869759276993,
+ 0.3228588962499004
+ ],
+ "fitted_temperature": 0.854572
+ },
+ "methods": {
+ "reference_single_10e": {
+ "accuracy": 98.47,
+ "nll": 0.044991,
+ "brier": 0.022366,
+ "ece": 0.003516,
+ "margin": 0.970575
+ },
+ "best_single_10e": {
+ "accuracy": 98.55,
+ "nll": 0.044944,
+ "brier": 0.022052,
+ "ece": 0.002515,
+ "margin": 0.97465
+ },
+ "single_50e": {
+ "accuracy": 98.6,
+ "nll": 0.062102,
+ "brier": 0.022912,
+ "ece": 0.008283,
+ "margin": 0.988829
+ },
+ "uniform_ensemble": {
+ "accuracy": 98.86,
+ "nll": 0.036184,
+ "brier": 0.01801,
+ "ece": 0.006311,
+ "margin": 0.968415
+ },
+ "uniform_temperature": {
+ "accuracy": 98.86,
+ "nll": 0.034129,
+ "brier": 0.017658,
+ "ece": 0.00334,
+ "margin": 0.974869
+ },
+ "slsqp_weights": {
+ "accuracy": 98.83,
+ "nll": 0.036179,
+ "brier": 0.017989,
+ "ece": 0.005818,
+ "margin": 0.969195
+ },
+ "pso_weights": {
+ "accuracy": 98.83,
+ "nll": 0.036178,
+ "brier": 0.017989,
+ "ece": 0.005817,
+ "margin": 0.969196
+ }
+ },
+ "confirmation_gates": {
+ "all_values_finite": true,
+ "official_test_dataset_loads": 1,
+ "official_test_pool_forward_passes": 5,
+ "official_test_long_single_forward_passes": 1,
+ "maximum_pso_accuracy_regression_vs_uniform_pp": true,
+ "pso_nll_below_reference_single": true,
+ "maximum_pso_nll_regression_vs_equal_budget_single": true,
+ "pass": true
+ }
+ }
+ },
+ "fashion_mnist": {
+ "provenance": {
+ "dataset_name": "FashionMNIST",
+ "split_seed": 20260904,
+ "search_samples": 50000,
+ "validation_samples": 10000,
+ "normalization": {
+ "mean": 0.28573352098464966,
+ "std": 0.35278451442718506
+ },
+ "data_fingerprint": "b56a39e2abf7d9ad",
+ "split_fingerprint": "489c1a04fb44b59a"
+ },
+ "training": {
+ "architecture": "CompactCNN",
+ "parameters": 9098,
+ "pool_seeds": [
+ 201,
+ 202,
+ 203,
+ 204,
+ 205
+ ],
+ "pool_epochs_each": 10,
+ "adam_pool_epochs": 50,
+ "adam_lr": 0.001,
+ "adam_batch_size": 256,
+ "adam_pool_wall_time_seconds": 22.363562541009742,
+ "single_50e_epochs": 50,
+ "single_50e_wall_time_seconds": 22.406685083013144,
+ "model_fingerprints": {
+ "201": "8189d6d2cce8bde8",
+ "single_50e": "5a5b8444219bf301",
+ "202": "a5492b64bfda73cd",
+ "203": "664e02f11e62031f",
+ "204": "be2a23fca4153703",
+ "205": "d3a37cfa6ee482bf"
+ }
+ },
+ "validation_cache": {
+ "valid": true,
+ "pool_forward_passes": 5,
+ "long_single_forward_passes": 1,
+ "base_cnn_forward_passes_during_optimization": 0,
+ "shape": [
+ 5,
+ 10000,
+ 10
+ ],
+ "memory_bytes": 2400000,
+ "wall_time_seconds": 0.08030625000537839
+ },
+ "validation": {
+ "methods": {
+ "reference_single_10e": {
+ "accuracy": 89.47,
+ "nll": 0.303799,
+ "brier": 0.150671,
+ "ece": 0.012197,
+ "margin": 0.808017
+ },
+ "best_single_10e": {
+ "accuracy": 89.47,
+ "nll": 0.303799,
+ "brier": 0.150671,
+ "ece": 0.012197,
+ "margin": 0.808017,
+ "selected_seed": 201
+ },
+ "single_50e": {
+ "accuracy": 90.32,
+ "nll": 0.28966,
+ "brier": 0.142115,
+ "ece": 0.024556,
+ "margin": 0.869484
+ },
+ "uniform_ensemble": {
+ "accuracy": 90.28,
+ "nll": 0.286751,
+ "brier": 0.142881,
+ "ece": 0.023702,
+ "margin": 0.795588
+ },
+ "uniform_temperature": {
+ "fitted_temperature": 0.906309,
+ "wall_time_seconds": 0.04135037500236649,
+ "evaluations": 21,
+ "metrics": {
+ "accuracy": 90.28,
+ "nll": 0.285048,
+ "brier": 0.141557,
+ "ece": 0.011886,
+ "margin": 0.814383
+ }
+ },
+ "slsqp_weights": {
+ "weights": [
+ 0.23910131729416598,
+ 0.2493341982620314,
+ 0.18054455195387528,
+ 0.021147090032828317,
+ 0.30987284245709906
+ ],
+ "evaluations": 23,
+ "wall_time_seconds": 0.010389625007519498,
+ "success": true,
+ "message": "Optimization terminated successfully",
+ "metrics": {
+ "accuracy": 90.42,
+ "nll": 0.285338,
+ "brier": 0.142289,
+ "ece": 0.023705,
+ "margin": 0.798413
+ }
+ },
+ "pso_weights": {
+ "per_seed_runs": [
+ {
+ "seed": 301,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "wall_time_seconds": 1.8963403329980792,
+ "metrics": {
+ "accuracy": 90.42,
+ "nll": 0.285338,
+ "brier": 0.142289,
+ "ece": 0.023661,
+ "margin": 0.798397
+ },
+ "weights": [
+ 0.2385721057653427,
+ 0.24956248700618744,
+ 0.1805897355079651,
+ 0.021864112466573715,
+ 0.30941155552864075
+ ]
+ },
+ {
+ "seed": 302,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "wall_time_seconds": 1.7477522080007475,
+ "metrics": {
+ "accuracy": 90.43,
+ "nll": 0.285338,
+ "brier": 0.142286,
+ "ece": 0.023912,
+ "margin": 0.79841
+ },
+ "weights": [
+ 0.2415684461593628,
+ 0.2483692765235901,
+ 0.18002673983573914,
+ 0.02121216244995594,
+ 0.30882343649864197
+ ]
+ },
+ {
+ "seed": 303,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "wall_time_seconds": 2.0081020840007113,
+ "metrics": {
+ "accuracy": 90.41,
+ "nll": 0.285338,
+ "brier": 0.14229,
+ "ece": 0.023601,
+ "margin": 0.798444
+ },
+ "weights": [
+ 0.23893120884895325,
+ 0.24851834774017334,
+ 0.18254171311855316,
+ 0.019977180287241936,
+ 0.31003159284591675
+ ]
+ }
+ ],
+ "selected_seed": 301,
+ "selected_weights": [
+ 0.2385721057653427,
+ 0.24956248700618744,
+ 0.1805897355079651,
+ 0.021864112466573715,
+ 0.30941155552864075
+ ],
+ "metrics": {
+ "accuracy": 90.42,
+ "nll": 0.285338,
+ "brier": 0.142289,
+ "ece": 0.023661,
+ "margin": 0.798397
+ },
+ "queries_per_seed": 900,
+ "sample_evaluations_per_seed": 9000000,
+ "total_queries": 2700,
+ "total_sample_evaluations": 27000000,
+ "median_one_seed_wall_time_seconds": 1.8963403329980792,
+ "total_wall_time_seconds": 5.652194624999538
+ }
+ }
+ },
+ "official_test_data_loaded_before_freeze": false,
+ "official_test_evaluations_before_freeze": 0,
+ "confirmation": {
+ "official_test_data_loaded": true,
+ "test_cache_counts": {
+ "dataset_loads": 1,
+ "pool_forward_passes": 5,
+ "long_single_forward_passes": 1,
+ "base_cnn_forward_passes_during_optimization": 0,
+ "memory_bytes": 2400000,
+ "wall_time_seconds": 0.11122124998655636
+ },
+ "frozen_methods": {
+ "selected_pso_seed": 301,
+ "selected_pso_weights": [
+ 0.2385721057653427,
+ 0.24956248700618744,
+ 0.1805897355079651,
+ 0.021864112466573715,
+ 0.30941155552864075
+ ],
+ "slsqp_weights": [
+ 0.23910131729416598,
+ 0.2493341982620314,
+ 0.18054455195387528,
+ 0.021147090032828317,
+ 0.30987284245709906
+ ],
+ "fitted_temperature": 0.906309
+ },
+ "methods": {
+ "reference_single_10e": {
+ "accuracy": 88.9,
+ "nll": 0.314516,
+ "brier": 0.161465,
+ "ece": 0.00532,
+ "margin": 0.805307
+ },
+ "best_single_10e": {
+ "accuracy": 88.9,
+ "nll": 0.314516,
+ "brier": 0.161465,
+ "ece": 0.00532,
+ "margin": 0.805307
+ },
+ "single_50e": {
+ "accuracy": 89.93,
+ "nll": 0.302348,
+ "brier": 0.148289,
+ "ece": 0.026401,
+ "margin": 0.865728
+ },
+ "uniform_ensemble": {
+ "accuracy": 89.65,
+ "nll": 0.293522,
+ "brier": 0.1514,
+ "ece": 0.019111,
+ "margin": 0.791698
+ },
+ "uniform_temperature": {
+ "accuracy": 89.65,
+ "nll": 0.291996,
+ "brier": 0.150581,
+ "ece": 0.007597,
+ "margin": 0.810594
+ },
+ "slsqp_weights": {
+ "accuracy": 89.54,
+ "nll": 0.291696,
+ "brier": 0.150558,
+ "ece": 0.017186,
+ "margin": 0.794293
+ },
+ "pso_weights": {
+ "accuracy": 89.54,
+ "nll": 0.2917,
+ "brier": 0.150559,
+ "ece": 0.017378,
+ "margin": 0.794274
+ }
+ },
+ "confirmation_gates": {
+ "all_values_finite": true,
+ "official_test_dataset_loads": 1,
+ "official_test_pool_forward_passes": 5,
+ "official_test_long_single_forward_passes": 1,
+ "maximum_pso_accuracy_regression_vs_uniform_pp": true,
+ "pso_nll_below_reference_single": true,
+ "maximum_pso_nll_regression_vs_equal_budget_single": true,
+ "pass": true
+ }
+ }
+ }
+ },
+ "development_pass": true,
+ "development_gates": {
+ "pass": true,
+ "failed_hard_gate_count": 0,
+ "gate_results": {
+ "all_values_finite": true,
+ "validation_pool_forward_passes_exact": true,
+ "optimization_base_model_forward_passes": true,
+ "official_test_data_loaded_before_freeze": true,
+ "slsqp_solver_success": true,
+ "query_and_sample_accounting_exact": true,
+ "maximum_pso_nll_regression_vs_uniform": true,
+ "maximum_pso_accuracy_regression_vs_uniform_pp": true,
+ "pso_nll_below_reference_single": true,
+ "maximum_pso_nll_regression_vs_equal_budget_single": true,
+ "maximum_relative_pso_nll_gap_vs_slsqp": true,
+ "cross_dataset_mean_relative_pso_nll_reduction_vs_uniform_minimum": true,
+ "maximum_median_one_seed_pso_to_pool_training_wall_ratio": true
+ },
+ "issues": []
+ },
+ "policy_frozen": true,
+ "official_test_data_loaded": true,
+ "official_test_evaluations_before_freeze": 0,
+ "post_test_tuning_or_reruns": 0,
+ "resource_totals": {
+ "adam_pool_epochs": 100,
+ "adam_pool_wall_time_seconds": 44.46244904199557,
+ "single_50e_wall_time_seconds": 44.473397291003494,
+ "validation_cache_forward_passes": 12,
+ "pso_total_queries": 5400,
+ "pso_total_sample_evaluations": 54000000,
+ "pso_research_wall_time_seconds": 11.151228083996102,
+ "pso_production_wall_time_seconds": 3.7888126670004567,
+ "pso_to_pool_wall_ratio": 0.0852162664640409,
+ "slsqp_total_evaluations": 46,
+ "slsqp_total_wall_time_seconds": 0.02007645901176147,
+ "official_test_cache_forward_passes": 12
+ }
+}
\ No newline at end of file
diff --git a/benchmark_results/pso_v8_post_training_ensemble_evaluation.json b/benchmark_results/pso_v8_post_training_ensemble_evaluation.json
new file mode 100644
index 0000000..5ad314c
--- /dev/null
+++ b/benchmark_results/pso_v8_post_training_ensemble_evaluation.json
@@ -0,0 +1,53 @@
+{
+ "evaluator_version": "POST-TRAINING-PSO-ENSEMBLE-EVALUATOR 1.2.0",
+ "pass": true,
+ "score": 22.55299842776338,
+ "development_pass": true,
+ "confirmation_pass": true,
+ "failed_hard_gate_count": 0,
+ "issues": {
+ "schema": [],
+ "config": [],
+ "finite": [],
+ "weights": [],
+ "accounting": [],
+ "leakage": [],
+ "tuning": [],
+ "slsqp": [],
+ "consistency": [],
+ "gates": []
+ },
+ "development_gates": {
+ "all_values_finite": true,
+ "simplex_tolerance": true,
+ "validation_pool_forward_passes_each_dataset": true,
+ "optimization_base_model_forward_passes": true,
+ "official_test_data_loaded_before_freeze": true,
+ "official_test_evaluations_before_freeze": true,
+ "query_and_sample_accounting_exact": true,
+ "maximum_pso_nll_regression_vs_uniform": true,
+ "maximum_pso_accuracy_regression_vs_uniform_pp": true,
+ "pso_nll_below_reference_single": true,
+ "maximum_pso_nll_regression_vs_equal_budget_single": true,
+ "maximum_relative_pso_nll_gap_vs_slsqp": true,
+ "cross_dataset_mean_relative_pso_nll_reduction_vs_uniform_minimum": true,
+ "maximum_median_one_seed_pso_to_pool_training_wall_ratio": true
+ },
+ "confirmation_gates": {
+ "all_values_finite": true,
+ "official_test_dataset_loads_each_dataset": true,
+ "official_test_pool_forward_passes_each_dataset": true,
+ "official_test_long_single_forward_passes_each_dataset": true,
+ "frozen_policy_consistency": true,
+ "maximum_pso_accuracy_regression_vs_uniform_pp": true,
+ "pso_nll_below_reference_single": true,
+ "maximum_pso_nll_regression_vs_equal_budget_single": true,
+ "post_test_tuning_or_reruns": true
+ },
+ "metrics": {
+ "mean_val_relative_nll_reduction_vs_equal_budget_single": 0.197261519715641,
+ "mean_val_accuracy_gain_vs_equal_budget_single_pp": 0.09500000000000597,
+ "mean_test_relative_nll_reduction_vs_equal_budget_single": 0.2263299842776338,
+ "mean_test_accuracy_gain_vs_equal_budget_single_pp": -0.0799999999999983
+ }
+}
\ No newline at end of file
diff --git a/conda_env/environment.yaml b/conda_env/environment.yaml
deleted file mode 100644
index 4a94185..0000000
--- a/conda_env/environment.yaml
+++ /dev/null
@@ -1,15 +0,0 @@
-name: pso
-channels:
- - conda-forge
- - defaults
-dependencies:
- - cudatoolkit=11.2
- - cudnn=8.1.0
- - pandas=1.5.3
- - pip=23.0.1
- - python=3.9.16
- - tqdm=4.65.0
- - pip:
- - numpy==1.25.0
- - tensorflow==2.11.0
- - tensorboard==2.11.0
diff --git a/example/pso2mnist.ipynb b/example/pso2mnist.ipynb
index 5afc5e5..87d7f84 100644
--- a/example/pso2mnist.ipynb
+++ b/example/pso2mnist.ipynb
@@ -1,2443 +1,284 @@
{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "colab_type": "text",
- "id": "view-in-github"
- },
- "source": [
- "![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\")
\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "BCG-8NlVLab8"
- },
- "source": [
- "# 기본 설치\n",
- "\n",
- "아래 명령어를 통해 설치할 수 있습니다\n",
- "\n",
- "```python\n",
- "!pip install pso2keras\n",
- "```\n",
- "\n",
- "필수 패키지로 tensorflow 가 필요하며, log 분석시에는 tensorboard 가 추가로 필요합니다\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "id": "Qd4s8Pu0nYGs"
- },
- "outputs": [],
- "source": [
- "import sys\n",
- "print('python version ', sys.version)\n",
- "\n",
- "# !pip uninstall pso2keras\n",
- "!pip install --upgrade pip\n",
- "!pip install pso2keras"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "Bs6TLWxLMmEw"
- },
- "source": [
- "# 모델 생성\n",
- "\n",
- "keras 모델을 사용하여 학습하기 때문에 모델을 생성하여 입력을 해주어야 합니다.\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "id": "bVWF-rQ3j_ld"
- },
- "outputs": [],
- "source": [
- "import os\n",
- "import sys\n",
- "\n",
- "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\"\n",
- "\n",
- "import gc\n",
- "\n",
- "import tensorflow as tf\n",
- "from keras.datasets import mnist\n",
- "from keras.layers import Conv2D, Dense, Dropout, Flatten, MaxPooling2D\n",
- "from keras.models import Sequential\n",
- "from tensorflow import keras\n",
- "\n",
- "from pso import Optimizer\n",
- "\n",
- "\n",
- "def get_data():\n",
- " (x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
- "\n",
- " x_train, x_test = x_train / 255.0, x_test / 255.0\n",
- " x_train = x_train.reshape((60000, 28, 28, 1))\n",
- " x_test = x_test.reshape((10000, 28, 28, 1))\n",
- "\n",
- " y_train, y_test = tf.one_hot(y_train, 10), tf.one_hot(y_test, 10)\n",
- "\n",
- " x_train, x_test = tf.convert_to_tensor(x_train), tf.convert_to_tensor(x_test)\n",
- " y_train, y_test = tf.convert_to_tensor(y_train), tf.convert_to_tensor(y_test)\n",
- "\n",
- " print(f\"x_train : {x_train[0].shape} | y_train : {y_train[0].shape}\")\n",
- " print(f\"x_test : {x_test[0].shape} | y_test : {y_test[0].shape}\")\n",
- "\n",
- " return x_train, y_train, x_test, y_test\n",
- "\n",
- "\n",
- "def get_data_test():\n",
- " (x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
- " x_test = x_test / 255.0\n",
- " x_test = x_test.reshape((10000, 28, 28, 1))\n",
- "\n",
- " y_test = tf.one_hot(y_test, 10)\n",
- "\n",
- " x_test = tf.convert_to_tensor(x_test)\n",
- " y_test = tf.convert_to_tensor(y_test)\n",
- "\n",
- " print(f\"x_test : {x_test[0].shape} | y_test : {y_test[0].shape}\")\n",
- "\n",
- " return x_test, y_test\n",
- "\n",
- "\n",
- "def make_model():\n",
- " model = Sequential()\n",
- " model.add(\n",
- " Conv2D(32, kernel_size=(5, 5), activation=\"relu\", input_shape=(28, 28, 1))\n",
- " )\n",
- " model.add(MaxPooling2D(pool_size=(3, 3)))\n",
- " model.add(Conv2D(64, kernel_size=(3, 3), activation=\"relu\"))\n",
- " model.add(MaxPooling2D(pool_size=(2, 2)))\n",
- " model.add(Dropout(0.25))\n",
- " model.add(Flatten())\n",
- " model.add(Dense(128, activation=\"relu\"))\n",
- " model.add(Dense(10, activation=\"softmax\"))\n",
- "\n",
- " return model"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "JKVXZC5fNjEr"
- },
- "source": [
- "# 학습\n",
- "\n",
- "학습을 위한 particle 개수와 기본 설정이 필요합니다\n",
- "loss 는 tensorflow 의 loss 를 활용합니다\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/",
- "height": 267,
- "referenced_widgets": [
- "60384954600849c984ec832f1e0ba089",
- "f4493e24f41f46d98a5c6307d4381858",
- "244e9d76fe934af2b536d4a41bd9ebc5",
- "64ee09f226ae41e8a8d7203db2370f64",
- "62129a4ae85b4aabb44cbb4c594ae7e5",
- "bd5692b1b8b4471f901e27df360f055e",
- "0cd1cd1ade0445a28f6020c1b52ed7f4",
- "f60caa635a1f4024b6bfd9bdc9a2d500",
- "f3452c1a31664a38b4ba3ad870cb9286",
- "262f741d45bf4069912d9e4ba4345450",
- "02e4861a0c934115bf494bca20a87e83",
- "0aa01a9086594c09b7be442781d15761",
- "55e5e64d8e484ae89b2bf56c0ce8a4e1",
- "b14bb35224404b58b2ea121b91152564",
- "8eacb4db3ae345bfa22f89ec79285648",
- "045717bfe98c420ebc4342d0061913a0",
- "6bd647b0e49c4d13b3a937dd325054d0",
- "86ccd693148940d29d5ed92a81a0d25c",
- "bf1ea704226b4fee9caed1a86bd6fc03",
- "bf625ea23d2c4aaa9cbc404fe88f0c61",
- "520f094d24d443e0b487d2717569f3b5",
- "eb816e9a17e245f5b0c41c552dd76183",
- "fae612998dec4856b30ebb2e5ececdfc",
- "fae548adc4294068a80d5b11572e411e",
- "415a6d555c95480da6fb9ad727ffd69a",
- "7e7a010af89d42bd94c558bb72d76230",
- "63d9eccdf7ea4a22a692cc1e0c1fbbc7",
- "822baf2dcccb41dcafc7139114a268a0",
- "f1599b1fafd6424483c5f404b3c79fd6",
- "6b60ab162f5a43e49904ea89ffe0f3ba",
- "b2a43a859d8e442d8d2dc8eb2cb489a4",
- "5c9870ced6f845f2909f706727ba5877",
- "456cfb7462d74aeab02f9a0af32f769f",
- "09eb0575ee1c4bd288b5f0a79c506f67",
- "cb35fee4c8a94812b209a61499687824",
- "bbca06083a094719a58367dce36c5fe0",
- "df7e251ff08b443f924eafcdf4627721",
- "c1026663b57243d5b4fd651d06b83beb",
- "fb4c68e932bc48ada671c11bd4b51fcb",
- "0efa7087787445f993e83a41ebc5136d",
- "95840eaab18b4dd6ba90acd7602112c1",
- "c1525b47e0d9487fb54849863ebaa4e0",
- "f20e024da5414b00becceb0541e3e45e",
- "1b6fed5a1fb24d7d8fcc7dfd7e56e618",
- "31537bf870cd4dbcbee4f55d1383a4f4",
- "78c7e54708884ef0bf3feadf4e86b27b",
- "de7b67b83e934558a122203e6314fb67",
- "00e855c093c947a2bf0c7ec644b6e401",
- "b4929212a2634d7ea12a77f79e4d61ff",
- "cbea21e8c9004b149bd86e1b0c1e67ce",
- "f1b4dc5fe13546c19c4bbfecb390e328",
- "0048352cbddf4e5282be22298975efc4",
- "52d399c1dfe4440baa77b540a2b5664c",
- "4ce75915aeb4484e9f1d3f6a2a262c76",
- "191804b6a0d64c1aafd50b1518c8e7e5",
- "872b2c7612c44b15bdcee774fb9e70b7",
- "b14aa26f85e148359bc9abff58951b51",
- "77a9f488c18c4487ae107bee7362b643",
- "b66fc8e0b5144229a69c5f2942ab796a",
- "bdda4512f2ec4290b29bf69d9b4808fe",
- "2fb4ef63d0824d36952f860f57e228ea",
- "a637e3a3a7144f6db19eb3bbd812722f",
- "8689e7f497fa4247b15f9929af81e68f",
- "bbf5277f6016441baa5a21a8059944d9",
- "814ff8b72e0e4f20877c85ba4ced21e6",
- "c63110ef853d411db16a41cb355324af"
- ]
- },
- "id": "wXmfci5UKNm4",
- "outputId": "c5bc9a2f-b949-4dac-e4d1-32942282cabf"
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n",
- "11490434/11490434 [==============================] - 0s 0us/step\n",
- "x_test : (28, 28, 1) | y_test : (10,)\n",
- "start running time : 20230723-095443\n"
- ]
- },
- {
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "60384954600849c984ec832f1e0ba089",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "Initializing Particles: 0%| | 0/500 [00:00"
+ ]
},
- "nbformat": 4,
- "nbformat_minor": 0
-}
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cell-1"
+ },
+ "source": [
+ "# pso2keras PyTorch 3.2.0 MNIST PSO Optimization\n",
+ "\n",
+ "이 노트북은 PyTorch `nn.Module`과 `pso2keras` (v3.2.0) 라이브러리를 사용하여 MNIST 이미지 분류 모델을 Particle Swarm Optimization (PSO) 알고리즘으로 최적화하는 예제입니다.\n",
+ "\n",
+ "> **환경 요구사항**:\n",
+ "> - Python 3.11 및 PyTorch >= 2.13.0\n",
+ "> - `uv` 패키지 관리자를 사용한 `pso2keras[examples]` 설치\n",
+ "> - MNIST 데이터셋 최초 다운로드를 위한 인터넷 연결 필요 (`torchvision.datasets.MNIST`)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cell-setup-md"
+ },
+ "source": [
+ "## 0. 패키지 설치 (Google Colab 및 시스템 환경)\n",
+ "\n",
+ "`uv` 패키지 관리자를 설치하고 `pso2keras[examples]` 패키지를 시스템 파이썬 환경에 설치합니다."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "cell-setup-code"
+ },
+ "outputs": [],
+ "source": [
+ "# Google Colab 및 시스템 환경 uv 패키지 설치\n",
+ "!pip install -q uv\n",
+ "!uv pip install 'pso2keras[examples]' --system"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "cell-2"
+ },
+ "outputs": [],
+ "source": [
+ "import sys\n",
+ "import torch\n",
+ "\n",
+ "print(\"Python version:\", sys.version)\n",
+ "print(\"PyTorch version:\", torch.__version__)\n",
+ "\n",
+ "# Metal MPS (Apple Silicon GPU) 가속 백엔드 진단\n",
+ "built = hasattr(torch.backends, \"mps\") and torch.backends.mps.is_built()\n",
+ "avail = hasattr(torch.backends, \"mps\") and torch.backends.mps.is_available()\n",
+ "print(f\"MPS Backend - Built: {built}, Available: {avail}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cell-3"
+ },
+ "source": [
+ "## 1. 데이터셋 다운로드 및 PCA 전처리\n",
+ "\n",
+ "`torchvision.datasets.MNIST`를 이용해 데이터셋을 다운로드하고, 결정론적(Deterministic) 서브셋을 추출합니다.\n",
+ "PSO 알고리즘의 파티클 탐색 효율을 높이기 위해 scikit-learn `PCA`를 사용하여 28x28 (784차원) 이미지를 50차원 피처 표현으로 압축합니다.\n",
+ "다중 클래스 분류(`task=\"multiclass\"`)를 위해 타겟 레이블은 1D 정수형(`torch.long` / `int64`) 클래스 인덱스로 구성합니다.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "cell-4"
+ },
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "import torch.nn as nn\n",
+ "from torchvision import datasets, transforms\n",
+ "from sklearn.decomposition import PCA\n",
+ "from pso import Optimizer\n",
+ "\n",
+ "# 재현 가능한 시드 설정\n",
+ "torch.manual_seed(42)\n",
+ "\n",
+ "# 1. MNIST 데이터셋 로드 (인터넷 다운로드 필요)\n",
+ "transform = transforms.Compose([transforms.ToTensor()])\n",
+ "mnist_train = datasets.MNIST(root=\"./data\", train=True, download=True, transform=transform)\n",
+ "mnist_test = datasets.MNIST(root=\"./data\", train=False, download=True, transform=transform)\n",
+ "\n",
+ "# 2. 결정론적 샘플 서브셋 추출 (학습 5,000개, 검증 1,000개)\n",
+ "g = torch.Generator().manual_seed(42)\n",
+ "train_indices = torch.randperm(len(mnist_train), generator=g)[:5000]\n",
+ "test_indices = torch.randperm(len(mnist_test), generator=g)[:1000]\n",
+ "\n",
+ "x_train_raw = mnist_train.data[train_indices].float() / 255.0\n",
+ "y_train = mnist_train.targets[train_indices].long()\n",
+ "\n",
+ "x_test_raw = mnist_test.data[test_indices].float() / 255.0\n",
+ "y_test = mnist_test.targets[test_indices].long()\n",
+ "\n",
+ "# 3. PCA 50차원 주성분 분석 전처리\n",
+ "x_train_flat = x_train_raw.view(x_train_raw.size(0), -1).numpy()\n",
+ "x_test_flat = x_test_raw.view(x_test_raw.size(0), -1).numpy()\n",
+ "\n",
+ "pca = PCA(n_components=50, random_state=42)\n",
+ "x_train_pca = pca.fit_transform(x_train_flat)\n",
+ "x_test_pca = pca.transform(x_test_flat)\n",
+ "\n",
+ "x_train = torch.tensor(x_train_pca, dtype=torch.float32)\n",
+ "x_test = torch.tensor(x_test_pca, dtype=torch.float32)\n",
+ "\n",
+ "print(f\"x_train : {x_train.shape} | y_train : {y_train.shape}\")\n",
+ "print(f\"x_test : {x_test.shape} | y_test : {y_test.shape}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cell-5"
+ },
+ "source": [
+ "## 2. PyTorch 신경망 모델 및 손실 함수 정의\n",
+ "\n",
+ "50개의 PCA 입력 피처를 받아 10개 클래스의 Raw Logits를 출력하는 소형 신경망 `MNISTLogitNet`을 정의합니다.\n",
+ "다중 클래스 분류를 위해 `nn.CrossEntropyLoss()`를 사용합니다.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "cell-6"
+ },
+ "outputs": [],
+ "source": [
+ "class MNISTLogitNet(nn.Module):\n",
+ " def __init__(self, in_features=50, hidden_dim=32, num_classes=10):\n",
+ " super().__init__()\n",
+ " self.net = nn.Sequential(\n",
+ " nn.Linear(in_features, hidden_dim),\n",
+ " nn.ReLU(),\n",
+ " nn.Linear(hidden_dim, num_classes)\n",
+ " )\n",
+ "\n",
+ " def forward(self, x):\n",
+ " return self.net(x)\n",
+ "\n",
+ "model = MNISTLogitNet()\n",
+ "loss_fn = nn.CrossEntropyLoss()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cell-7"
+ },
+ "source": [
+ "## 3. PSO Optimizer 생성 및 최적화 실행\n",
+ "\n",
+ "`Optimizer` 생성자에 PyTorch 모델, 손실 함수, 작업 유형(`task=\"multiclass\"`), 이동 방식(`method=\"inertia\"`), 초기화 방식(`initialization=\"model_noise\"`), 적합도 평가 방식(`evaluation=\"fixed_subset\"`), 수렴 방식(`convergence=\"none\"`), 후속 정제 방식(`refinement=\"adam\"`), 파티클 개수(`n_particles`), 이동 계수(`c0`, `c1`, `w_min`, `w_max`), 가중치 경계(`particle_min`, `particle_max`), 속도 제한 비율(`velocity_limit_ratio`), 경계 전략(`boundary_strategy`), 초기 노이즈 스케일(`initial_position_noise`), 시드(`seed`)를 설정합니다.\n",
+ "\n",
+ "`device=None`을 지정하면 MPS (Apple Silicon GPU) -> CUDA -> CPU 순서로 실행 디바이스를 자동 선택합니다.\n",
+ "\n",
+ "`fit` 메서드에 고정 적합도 서브셋 크기(`fitness_size=2000`), 배치 크기(`batch_size=500`), 검증 데이터셋(`validation_data=(x_test, y_test)`), 하이브리드 Adam 국소 정제(`refinement_epochs=100`, `refinement_lr=0.01`), 결과 디렉토리(`output_dir=\"./result/mnist\"`)를 지정하여 최적화를 수행합니다.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "cell-8"
+ },
+ "outputs": [],
+ "source": [
+ "pso_mnist = Optimizer(\n",
+ " model,\n",
+ " loss=loss_fn,\n",
+ " task=\"multiclass\",\n",
+ " method=\"inertia\",\n",
+ " initialization=\"model_noise\",\n",
+ " evaluation=\"fixed_subset\",\n",
+ " convergence=\"none\",\n",
+ " refinement=\"adam\",\n",
+ " fitness_size=2000,\n",
+ " n_particles=20,\n",
+ " c0=0.35,\n",
+ " c1=0.8,\n",
+ " w_min=0.6,\n",
+ " w_max=1.2,\n",
+ " particle_min=-3.0,\n",
+ " particle_max=3.0,\n",
+ " velocity_limit_ratio=0.1,\n",
+ " boundary_strategy=\"reflect\",\n",
+ " initial_position_noise=0.05,\n",
+ " seed=42,\n",
+ " device=None,\n",
+ " refinement_epochs=100,\n",
+ " refinement_lr=0.01,\n",
+ ")\n",
+ "\n",
+ "best_score = pso_mnist.fit(\n",
+ " x_train,\n",
+ " y_train,\n",
+ " epochs=15,\n",
+ " batch_size=500,\n",
+ " fitness_size=2000,\n",
+ " renewal=\"acc\",\n",
+ " validation_data=(x_test, y_test),\n",
+ " output_dir=\"./result/mnist\",\n",
+ " log_format=\"csv\",\n",
+ " checkpoint_interval=5,\n",
+ " save_info=True,\n",
+ " refinement_epochs=100,\n",
+ " refinement_lr=0.01,\n",
+ ")\n",
+ "\n",
+ "print(f\"Optimization Completed! Best Training Score (loss, accuracy, mse): {best_score}\")\n",
+ "val_score = pso_mnist.evaluate(x_test, y_test)\n",
+ "print(f\"Validation Score (loss, accuracy, mse): {val_score}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cell-9"
+ },
+ "source": [
+ "## 4. 최적 모델 체크포인트 로드 및 이식 가능한 모델 검증\n",
+ "\n",
+ "학습이 완료되면 `output_dir` 하위에 `best_model.pt` 체크포인트 파일이 저장됩니다.\n",
+ "`torch.load()`를 사용하여 `model_state_dict`를 읽어온 뒤 새로운 `MNISTLogitNet` 인스턴스에 로드하여 가중치를 재복원할 수 있습니다.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "cell-10"
+ },
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "\n",
+ "ckpt_path = \"./result/mnist/best_model.pt\"\n",
+ "if os.path.exists(ckpt_path):\n",
+ " checkpoint = torch.load(ckpt_path, weights_only=True)\n",
+ " \n",
+ " # 이식 가능한 state_dict 기반 모델 가중치 복원\n",
+ " eval_model = MNISTLogitNet()\n",
+ " eval_model.load_state_dict(checkpoint[\"model_state_dict\"])\n",
+ " eval_model.eval()\n",
+ "\n",
+ " print(\"Loaded Checkpoint Version:\", checkpoint.get(\"version\"))\n",
+ " print(\"Checkpoint Best Score: \", checkpoint.get(\"score\"))\n",
+ " print(\"Execution Target Device: \", checkpoint.get(\"device\"))\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "language_info": {
+ "name": "python",
+ "version": "3.10.0"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
\ No newline at end of file
diff --git a/history_plt/pso_v4_accuracy.png b/history_plt/pso_v4_accuracy.png
new file mode 100644
index 0000000..e858cdb
Binary files /dev/null and b/history_plt/pso_v4_accuracy.png differ
diff --git a/history_plt/pso_v4_deep_accuracy.png b/history_plt/pso_v4_deep_accuracy.png
new file mode 100644
index 0000000..94efec6
Binary files /dev/null and b/history_plt/pso_v4_deep_accuracy.png differ
diff --git a/history_plt/pso_v4_epoch_convergence.png b/history_plt/pso_v4_epoch_convergence.png
new file mode 100644
index 0000000..2746dcb
Binary files /dev/null and b/history_plt/pso_v4_epoch_convergence.png differ
diff --git a/history_plt/pso_v4_extended_tuning.png b/history_plt/pso_v4_extended_tuning.png
new file mode 100644
index 0000000..3289e91
Binary files /dev/null and b/history_plt/pso_v4_extended_tuning.png differ
diff --git a/history_plt/pso_v4_full_mnist.png b/history_plt/pso_v4_full_mnist.png
new file mode 100644
index 0000000..7fc3622
Binary files /dev/null and b/history_plt/pso_v4_full_mnist.png differ
diff --git a/history_plt/pso_v4_loss.png b/history_plt/pso_v4_loss.png
new file mode 100644
index 0000000..5f0a771
Binary files /dev/null and b/history_plt/pso_v4_loss.png differ
diff --git a/history_plt/pso_v4_mnist_ablation.png b/history_plt/pso_v4_mnist_ablation.png
new file mode 100644
index 0000000..1d33ed7
Binary files /dev/null and b/history_plt/pso_v4_mnist_ablation.png differ
diff --git a/history_plt/pso_v4_particle_scaling.png b/history_plt/pso_v4_particle_scaling.png
new file mode 100644
index 0000000..e701b16
Binary files /dev/null and b/history_plt/pso_v4_particle_scaling.png differ
diff --git a/history_plt/pso_v4_rank_heatmap.png b/history_plt/pso_v4_rank_heatmap.png
new file mode 100644
index 0000000..5f0307d
Binary files /dev/null and b/history_plt/pso_v4_rank_heatmap.png differ
diff --git a/history_plt/pso_v4_runtime.png b/history_plt/pso_v4_runtime.png
new file mode 100644
index 0000000..f9e1459
Binary files /dev/null and b/history_plt/pso_v4_runtime.png differ
diff --git a/history_plt/pso_v5_deep_methods.png b/history_plt/pso_v5_deep_methods.png
new file mode 100644
index 0000000..3a461ea
Binary files /dev/null and b/history_plt/pso_v5_deep_methods.png differ
diff --git a/history_plt/pso_v6_heavy_autoresearch.png b/history_plt/pso_v6_heavy_autoresearch.png
new file mode 100644
index 0000000..132af4c
Binary files /dev/null and b/history_plt/pso_v6_heavy_autoresearch.png differ
diff --git a/history_plt/pso_v6_heavy_tasks.png b/history_plt/pso_v6_heavy_tasks.png
new file mode 100644
index 0000000..d98633b
Binary files /dev/null and b/history_plt/pso_v6_heavy_tasks.png differ
diff --git a/history_plt/pso_v6_phase_b.png b/history_plt/pso_v6_phase_b.png
new file mode 100644
index 0000000..d318413
Binary files /dev/null and b/history_plt/pso_v6_phase_b.png differ
diff --git a/history_plt/pso_v7_heavy_cross_split.png b/history_plt/pso_v7_heavy_cross_split.png
new file mode 100644
index 0000000..dcdd77d
Binary files /dev/null and b/history_plt/pso_v7_heavy_cross_split.png differ
diff --git a/history_plt/pso_v8_post_training_ensemble.png b/history_plt/pso_v8_post_training_ensemble.png
new file mode 100644
index 0000000..5068fa5
Binary files /dev/null and b/history_plt/pso_v8_post_training_ensemble.png differ
diff --git a/pso/__init__.py b/pso/__init__.py
index 02bacb4..b2d73d2 100644
--- a/pso/__init__.py
+++ b/pso/__init__.py
@@ -1,22 +1,29 @@
-import tensorflow as tf
-import os
-from .optimizer import Optimizer as optimizer
-from .particle import Particle as particle
-
-__version__ = "1.0.5.1"
-
-print("pso2keras version : " + __version__)
-
-gpus = tf.config.experimental.list_physical_devices("GPU")
-if gpus:
- try:
- tf.config.experimental.set_memory_growth(gpus[0], True)
- except RuntimeError as r:
- print(r)
-
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+from ._version import __version__
+from .optimizer import Optimizer
+from .particle import Particle
+from .plugins import (
+ BasePlugin,
+ InitializationPlugin,
+ EvaluationPlugin,
+ MovementPlugin,
+ ConvergencePlugin,
+ RefinementPlugin,
+ PluginMetadata,
+ SwarmState,
+ available_plugins,
+)
__all__ = [
- "optimizer",
- "particle",
+ "Optimizer",
+ "Particle",
+ "__version__",
+ "BasePlugin",
+ "InitializationPlugin",
+ "EvaluationPlugin",
+ "MovementPlugin",
+ "ConvergencePlugin",
+ "RefinementPlugin",
+ "PluginMetadata",
+ "SwarmState",
+ "available_plugins",
]
diff --git a/pso/_version.py b/pso/_version.py
new file mode 100644
index 0000000..34fc8bd
--- /dev/null
+++ b/pso/_version.py
@@ -0,0 +1,22 @@
+from pathlib import Path
+import sys
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+ __version__ = version("pso2keras")
+except PackageNotFoundError:
+ pyproject_path = Path(__file__).resolve().parent.parent / "pyproject.toml"
+ if pyproject_path.exists():
+ if sys.version_info >= (3, 11):
+ import tomllib
+ else:
+ try:
+ import tomllib # type: ignore
+ except ImportError:
+ import tomli as tomllib # type: ignore
+
+ with pyproject_path.open("rb") as f:
+ data = tomllib.load(f)
+ __version__ = data["project"]["version"]
+ else:
+ __version__ = "0.0.0"
diff --git a/pso/_weights.py b/pso/_weights.py
new file mode 100644
index 0000000..aa29624
--- /dev/null
+++ b/pso/_weights.py
@@ -0,0 +1,88 @@
+import collections
+import torch
+import torch.nn as nn
+
+
+class ParameterCodec:
+ """
+ Private parameter encoder/decoder for flattening and reconstructing PyTorch nn.Module parameters.
+ """
+
+ def __init__(self, model: nn.Module):
+ if not isinstance(model, nn.Module):
+ raise TypeError("model must be an instance of torch.nn.Module")
+
+ params = list(model.named_parameters())
+ if not params:
+ raise ValueError("model contains zero trainable parameters")
+
+ self.names: list[str] = []
+ self.shapes: list[tuple[int, ...]] = []
+ self.numels: list[int] = []
+ dtypes: set[torch.dtype] = set()
+
+ total_size = 0
+ for name, p in params:
+ if not p.dtype.is_floating_point:
+ raise ValueError(
+ f"Parameter '{name}' has non-floating dtype {p.dtype}. Only floating-point parameters are supported."
+ )
+ self.names.append(name)
+ self.shapes.append(tuple(p.shape))
+ n = p.numel()
+ self.numels.append(n)
+ total_size += n
+ dtypes.add(p.dtype)
+
+ if len(dtypes) > 1:
+ raise ValueError(f"Mixed parameter dtypes found in model: {dtypes}")
+
+ self.dtype: torch.dtype = next(iter(dtypes))
+ self.size: int = total_size
+
+ def encode(self, model: nn.Module) -> torch.Tensor:
+ """
+ Flattens model parameters into a single detached 1D torch.Tensor.
+ """
+ params = [p for _, p in model.named_parameters()]
+ return nn.utils.parameters_to_vector(params).detach()
+
+ def apply_vector(self, vector: torch.Tensor, model: nn.Module) -> None:
+ """
+ Applies a validated 1D parameter vector to model.parameters() in-place without storage aliasing.
+ """
+ if not isinstance(vector, torch.Tensor) or vector.ndim != 1:
+ raise ValueError("vector must be a 1D torch.Tensor")
+ if vector.numel() != self.size:
+ raise ValueError(
+ f"Vector size {vector.numel()} does not match codec size {self.size}"
+ )
+ if vector.dtype != self.dtype:
+ raise ValueError(
+ f"Vector dtype {vector.dtype} does not match codec dtype {self.dtype}"
+ )
+
+ params = [p for _, p in model.named_parameters()]
+ if params:
+ target_device = params[0].device
+ if vector.device != target_device:
+ vector = vector.to(target_device)
+
+ with torch.no_grad():
+ offset = 0
+ for p, shape, numel in zip(params, self.shapes, self.numels):
+ p.copy_(vector[offset : offset + numel].reshape(shape))
+ offset += numel
+
+ def to_state_dict(
+ self, vector: torch.Tensor, eval_model: nn.Module
+ ) -> collections.OrderedDict[str, torch.Tensor]:
+ """
+ Applies vector to eval_model and returns a defensive CPU-cloned ordered state dict including buffers.
+ """
+ self.apply_vector(vector, eval_model)
+ state_dict = eval_model.state_dict()
+ res = collections.OrderedDict()
+ for k, v in state_dict.items():
+ res[k] = v.detach().cpu().clone()
+ return res
diff --git a/pso/optimizer.py b/pso/optimizer.py
index a4a780f..4e09456 100644
--- a/pso/optimizer.py
+++ b/pso/optimizer.py
@@ -1,759 +1,1677 @@
-import atexit
-import gc
+import collections
+import copy
+import csv
import json
+import math
import os
-import socket
-import subprocess
-import sys
-from datetime import datetime
+from typing import Any, Literal, Sequence
+import torch
+import torch.nn as nn
-import numpy as np
-import tensorflow as tf
-from sklearn.model_selection import train_test_split
-from tensorboard.plugins.hparams import api as hp
-from tensorflow import keras
-from tqdm.auto import tqdm
-from typing import Any, List
+from ._version import __version__
+from ._weights import ParameterCodec
from .particle import Particle
+from .plugins import (
+ BasePlugin,
+ ConvergencePlugin,
+ EvaluationPlugin,
+ FitContext,
+ InitializationPlugin,
+ IterationContext,
+ MovementPlugin,
+ PluginMetadata,
+ RefinementPlugin,
+ SwarmState,
+ _is_at_least_delta,
+ _is_better_score,
+ get_plugin,
+)
-def find_free_port():
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- sock.bind(("localhost", 0))
- port = sock.getsockname()[1]
- sock.close()
- return port
+def resolve_device(device: str | torch.device | None = None) -> torch.device:
+ """
+ Resolves execution device.
+ If device is None, auto-selects mps if available & built, else cuda, else cpu.
+ Explicit device requirement ('mps', 'cuda', 'cpu') checks availability or raises RuntimeError.
+ """
+ if device is None:
+ if (
+ hasattr(torch.backends, "mps")
+ and torch.backends.mps.is_built()
+ and torch.backends.mps.is_available()
+ ):
+ return torch.device("mps")
+ elif torch.cuda.is_available():
+ return torch.device("cuda")
+ else:
+ return torch.device("cpu")
+ if isinstance(device, str):
+ try:
+ dev = torch.device(device)
+ except RuntimeError as e:
+ raise ValueError(f"Unsupported device type: '{device}'") from e
+ elif isinstance(device, torch.device):
+ dev = device
+ else:
+ raise TypeError(
+ f"device must be a string, torch.device, or None, got {type(device)}"
+ )
+
+ if dev.type == "mps":
+ built = hasattr(torch.backends, "mps") and torch.backends.mps.is_built()
+ avail = hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+ if not (built and avail):
+ raise RuntimeError(
+ f"Explicit MPS device requested ('{device}'), but PyTorch MPS backend is not available (built={built}, available={avail})."
+ )
+ elif dev.type == "cuda":
+ if not torch.cuda.is_available():
+ raise RuntimeError(
+ f"Explicit CUDA device requested ('{device}'), but CUDA is not available."
+ )
+ elif dev.type == "cpu":
+ pass
+ else:
+ raise ValueError(
+ f"Unsupported device type: '{dev.type}'. Only 'cpu', 'cuda', and 'mps' are supported."
+ )
+
+ return dev
+
+
+def _is_better_score(
+ new_score: tuple[float, float, float],
+ best_score: tuple[float, float, float] | None,
+ renewal: str = "acc",
+) -> bool:
+ """
+ Returns True if new_score is strictly better than best_score according to renewal
+ metric and deterministic tie breaks (loss asc, accuracy desc, mse asc).
+ """
+ if best_score is None:
+ return True
+
+ n_loss, n_acc, n_mse = new_score
+ b_loss, b_acc, b_mse = best_score
+
+ if renewal in ("acc", "accuracy"):
+ if n_acc != b_acc:
+ return n_acc > b_acc
+ elif renewal == "loss":
+ if n_loss != b_loss:
+ return n_loss < b_loss
+ elif renewal == "mse":
+ if n_mse != b_mse:
+ return n_mse < b_mse
+ else:
+ raise ValueError(f"Unknown renewal metric: {renewal}")
+
+ if n_loss != b_loss:
+ return n_loss < b_loss
+ if n_acc != b_acc:
+ return n_acc > b_acc
+ if n_mse != b_mse:
+ return n_mse < b_mse
+
+ return False
+
+
+def _is_at_least_delta(delta: float, min_delta: float) -> bool:
+ """
+ Returns True if directional improvement delta meets min_delta, handling floating-point boundaries.
+ """
+ if min_delta > 0:
+ return delta > min_delta or math.isclose(
+ delta, min_delta, rel_tol=1e-12, abs_tol=1e-15
+ )
+ return delta > 0
+
+
+def _validate_score(
+ score: Sequence[Any], particle_idx: int, iteration: int
+) -> tuple[float, float, float]:
+ """
+ Validates that a score sequence contains 3 finite numbers.
+ Raises FloatingPointError naming particle index and iteration if non-finite.
+ """
+ try:
+ parsed = (float(score[0]), float(score[1]), float(score[2]))
+ except (IndexError, TypeError, ValueError) as e:
+ raise FloatingPointError(
+ f"Invalid score format {score} for particle {particle_idx} at iteration {iteration}"
+ ) from e
+
+ if not all(math.isfinite(x) for x in parsed):
+ raise FloatingPointError(
+ f"Non-finite score {parsed} encountered for particle {particle_idx} at iteration {iteration}"
+ )
+ return parsed
+
+
+class _RandomSource:
+ """
+ Private CPU/device random generator wrapper for drawing stochastic tensors and events.
+ Transfers generated tensors to reference device and dtype if needed.
+ """
+
+ def __init__(self, seed: int | None = None, device: torch.device | str = "cpu"):
+ self.cpu_generator = torch.Generator(device="cpu")
+ dev = resolve_device(device) if not isinstance(device, torch.device) else device
+ self.search_generator = (
+ self.cpu_generator
+ if dev.type == "cpu"
+ else torch.Generator(device=dev)
+ )
+
+ if seed is not None:
+ self.cpu_generator.manual_seed(seed)
+ if self.search_generator is not self.cpu_generator:
+ self.search_generator.manual_seed(seed)
+ else:
+ self.cpu_generator.seed()
+ if self.search_generator is not self.cpu_generator:
+ self.search_generator.seed()
+
+ def uniform(
+ self,
+ shape: torch.Size | tuple[int, ...],
+ low: float = 0.0,
+ high: float = 1.0,
+ device: torch.device | str | None = None,
+ dtype: torch.dtype = torch.float32,
+ ) -> torch.Tensor:
+ if device is None:
+ target_dev = self.search_generator.device
+ else:
+ target_dev = (
+ resolve_device(device) if not isinstance(device, torch.device) else device
+ )
+
+ if self.search_generator.device.type == target_dev.type:
+ r = torch.rand(
+ shape, generator=self.search_generator, device=target_dev, dtype=dtype
+ )
+ else:
+ r = torch.rand(
+ shape, generator=self.cpu_generator, device="cpu", dtype=dtype
+ ).to(device=target_dev, dtype=dtype)
+ return low + (high - low) * r
+ def bernoulli_event(self, p: float) -> bool:
+ r = torch.rand((1,), generator=self.cpu_generator, device="cpu").item()
+ return r < p
+
+ def permutation(self, n: int) -> torch.Tensor:
+ return torch.randperm(n, generator=self.cpu_generator, device="cpu")
+
+ def choice(self, n: int, size: int) -> torch.Tensor:
+ perm = torch.randperm(n, generator=self.cpu_generator, device="cpu")
+ return perm[:size]
+
+ def randint(
+ self,
+ low: int,
+ high: int,
+ size: tuple[int, ...] | int | None = None,
+ device: torch.device | str | None = None,
+ ) -> torch.Tensor:
+ if size is None:
+ shape = (1,)
+ elif isinstance(size, int):
+ shape = (size,)
+ else:
+ shape = size
+ r = torch.randint(
+ low=low,
+ high=high,
+ size=shape,
+ generator=self.cpu_generator,
+ device="cpu",
+ )
+ if device is not None and str(device) != "cpu":
+ return r.to(device)
+ return r
class Optimizer:
"""
- particle swarm optimization
- PSO 실행을 위한 클래스
+ Particle Swarm Optimizer for PyTorch nn.Module models with stage-plugin architecture.
"""
def __init__(
self,
- model: keras.Model,
- loss: Any,
- **kwargs,
+ model: nn.Module,
+ loss: nn.Module,
+ *,
+ task: Literal["binary", "multiclass", "regression"],
+ method: str | MovementPlugin = "original",
+ initialization: str | InitializationPlugin = "model_noise",
+ evaluation: str | EvaluationPlugin = "full",
+ convergence: str | ConvergencePlugin = "none",
+ refinement: str | RefinementPlugin = "none",
+ method_options: dict[str, Any] | None = None,
+ n_particles: int = 10,
+ c0: float | None = None,
+ c1: float | None = None,
+ w_min: float | None = None,
+ w_max: float | None = None,
+ negative_swarm: float = 0.0,
+ mutation_swarm: float = 0.0,
+ particle_min: float | None = None,
+ particle_max: float | None = None,
+ velocity_limit_ratio: float | None = None,
+ boundary_strategy: Literal["clip", "reflect"] = "clip",
+ initial_position_noise: float = 0.05,
+ seed: int | None = None,
+ device: str | torch.device | None = None,
+ fitness_size: int | None = None,
+ convergence_patience: int = 10,
+ convergence_min_delta: float = 0.0001,
+ convergence_monitor: str = "loss",
+ refinement_epochs: int = 0,
+ refinement_lr: float = 0.001,
+ moment_blend: float | None = None,
+ moment_beta1: float | None = None,
+ moment_beta2: float | None = None,
+ moment_step_size: float | None = None,
+ moment_epsilon: float | None = None,
):
- """
- particle swarm optimization
+ if model is None or not isinstance(model, nn.Module):
+ raise ValueError("model must be an instance of torch.nn.Module")
- Args:
- model (keras.models): 모델 구조 - keras.models.model_from_json 을 이용하여 생성
- loss (str): 손실함수 - keras.losses 에서 제공하는 손실함수 사용
- n_particles (int): 파티클 개수
- c0 (float): local rate - 지역 최적값 관성 수치
- c1 (float): global rate - 전역 최적값 관성 수치
- w_min (float): 최소 관성 수치
- w_max (float): 최대 관성 수치
- negative_swarm (float): 최적해와 반대로 이동할 파티클 비율 - 0 ~ 1 사이의 값
- mutation_swarm (float): 돌연변이가 일어날 확률 - 0 ~ 1 사이의 값
- np_seed (int | None): numpy seed. Defaults to None.
- tf_seed (int | None): tensorflow seed. Defaults to None.
- random_state (tuple): numpy random state. Defaults to None.
- convergence_reset (bool): early stopping 사용 여부. Defaults to False.
- convergence_reset_patience (int): early stopping 사용시 얼마나 기다릴지. Defaults to 10.
- convergence_reset_min_delta (float): early stopping 사용시 얼마나 기다릴지. Defaults to 0.0001.
- convergence_reset_monitor (str): early stopping 사용시 어떤 값을 기준으로 할지. Defaults to "loss". - "loss" or "acc" or "mse"
- """
+ if loss is None or not isinstance(loss, nn.Module):
+ raise ValueError("loss must be an instance of torch.nn.Module")
- try:
- n_particles = kwargs.get("n_particles", 10)
- c0 = kwargs.get("c0", 0.5)
- c1 = kwargs.get("c1", 0.3)
- w_min = kwargs.get("w_min", 0.1)
- w_max = kwargs.get("w_max", 0.9)
- negative_swarm = kwargs.get("negative_swarm", 0)
- mutation_swarm = kwargs.get("mutation_swarm", 0)
- np_seed = kwargs.get("np_seed", None)
- tf_seed = kwargs.get("tf_seed", None)
- random_state = kwargs.get("random_state", None)
- convergence_reset = kwargs.get("convergence_reset", False)
- convergence_reset_patience = kwargs.get("convergence_reset_patience", 10)
- convergence_reset_min_delta = kwargs.get(
- "convergence_reset_min_delta", 0.0001
+ if task not in ("binary", "multiclass", "regression"):
+ raise ValueError(
+ "task must be one of 'binary', 'multiclass', 'regression'"
)
- convergence_reset_monitor = kwargs.get("convergence_reset_monitor", "loss")
- if model is None:
- raise ValueError("model is None")
- elif model is not None and not isinstance(model, keras.models.Model):
- raise ValueError("model is not keras.models.Model")
+ if (
+ isinstance(n_particles, bool)
+ or not isinstance(n_particles, int)
+ or n_particles < 1
+ ):
+ raise ValueError("n_particles must be an integer >= 1")
- elif loss is None:
- raise ValueError("loss is None")
+ for name, val in [
+ ("c0", c0),
+ ("c1", c1),
+ ("w_min", w_min),
+ ("w_max", w_max),
+ ("moment_blend", moment_blend),
+ ("moment_beta1", moment_beta1),
+ ("moment_beta2", moment_beta2),
+ ("moment_step_size", moment_step_size),
+ ("moment_epsilon", moment_epsilon),
+ ]:
+ if val is not None and (
+ isinstance(val, bool)
+ or not isinstance(val, (int, float))
+ or not math.isfinite(val)
+ ):
+ raise ValueError(f"{name} must be a finite number")
- elif n_particles is None:
- raise ValueError("n_particles is None")
- elif n_particles < 1:
- raise ValueError("n_particles < 1")
+ if w_min is not None and w_max is not None and float(w_min) > float(w_max):
+ raise ValueError("w_min must be <= w_max")
- elif c0 < 0 or c1 < 0:
- raise ValueError("c0 or c1 < 0")
+ for name, val in [
+ ("negative_swarm", negative_swarm),
+ ("mutation_swarm", mutation_swarm),
+ ]:
+ if (
+ isinstance(val, bool)
+ or not isinstance(val, (int, float))
+ or not math.isfinite(val)
+ or not (0.0 <= float(val) <= 1.0)
+ ):
+ raise ValueError(f"{name} must be a finite float in range [0, 1]")
- elif np_seed is not None:
- np.random.seed(np_seed)
- elif tf_seed is not None:
- tf.random.set_seed(tf_seed)
+ if (particle_min is None) != (particle_max is None):
+ raise ValueError("particle_min and particle_max must be provided together")
- elif random_state is not None:
- np.random.set_state(random_state)
+ if particle_min is not None and particle_max is not None:
+ if (
+ isinstance(particle_min, bool)
+ or not isinstance(particle_min, (int, float))
+ or not math.isfinite(particle_min)
+ ):
+ raise ValueError("particle_min must be a finite number")
+ if (
+ isinstance(particle_max, bool)
+ or not isinstance(particle_max, (int, float))
+ or not math.isfinite(particle_max)
+ ):
+ raise ValueError("particle_max must be a finite number")
+ if particle_min > particle_max:
+ raise ValueError("particle_min must be <= particle_max")
- self.random_state = np.random.get_state()
-
- model.compile(loss=loss, optimizer="adam", metrics=["accuracy", "mse"])
- self.model = model # 모델 구조
- self.set_shape(model.get_weights())
- self.loss = loss # 손실함수
- self.n_particles = n_particles # 파티클 개수
- self.particles = [None] * n_particles # 파티클 리스트
- self.c0 = c0 # local rate - 지역 최적값 관성 수치
- self.c1 = c1 # global rate - 전역 최적값 관성 수치
- self.w_min = w_min # 최소 관성 수치
- self.w_max = w_max # 최대 관성 수치
- self.negative_swarm = (
- negative_swarm # 최적해와 반대로 이동할 파티클 비율 - 0 ~ 1 사이의 값
- )
- self.mutation_swarm = (
- mutation_swarm # 관성을 추가로 사용할 파티클 비율 - 0 ~ 1 사이의 값
- )
- self.avg_score = 0 # 평균 점수
-
- self.renewal = "acc"
- self.dispersion = False
- self.day = datetime.now().strftime("%Y%m%d-%H%M%S")
-
- self.empirical_balance = False
-
- negative_count = 0
-
- self.train_summary_writer = [None] * self.n_particles
-
- print(f"start running time : {self.day}")
- for i in tqdm(range(self.n_particles), desc="Initializing Particles"):
- self.particles[i] = Particle(
- model,
- self.loss,
- negative=(
- True if i < self.negative_swarm * self.n_particles else False
- ),
- mutation=self.mutation_swarm,
- converge_reset=convergence_reset,
- converge_reset_patience=convergence_reset_patience,
- converge_reset_monitor=convergence_reset_monitor,
- converge_reset_min_delta=convergence_reset_min_delta,
+ if velocity_limit_ratio is not None:
+ if (
+ isinstance(velocity_limit_ratio, bool)
+ or not isinstance(velocity_limit_ratio, (int, float))
+ or not math.isfinite(velocity_limit_ratio)
+ or not (0.0 < float(velocity_limit_ratio) <= 1.0)
+ ):
+ raise ValueError(
+ "velocity_limit_ratio must be a finite float in range (0, 1]"
+ )
+ if particle_min is None or particle_max is None:
+ raise ValueError(
+ "velocity_limit_ratio requires paired particle_min and particle_max bounds"
+ )
+ if particle_min >= particle_max:
+ raise ValueError(
+ "velocity_limit_ratio requires particle_min < particle_max"
)
- if i < self.negative_swarm * self.n_particles:
- negative_count += 1
+ if boundary_strategy not in ("clip", "reflect"):
+ raise ValueError("boundary_strategy must be one of 'clip', 'reflect'")
- gc.collect()
- tf.keras.backend.reset_uids()
- tf.keras.backend.clear_session()
+ if boundary_strategy == "reflect":
+ if particle_min is None or particle_max is None:
+ raise ValueError(
+ "boundary_strategy 'reflect' requires paired particle_min and particle_max bounds"
+ )
+ if particle_min >= particle_max:
+ raise ValueError(
+ "boundary_strategy 'reflect' requires particle_min < particle_max"
+ )
- print(f"negative swarm : {negative_count} / {n_particles}")
- print(f"mutation swarm : {mutation_swarm * 100}%")
-
- gc.collect()
- tf.keras.backend.reset_uids()
- tf.keras.backend.clear_session()
- except KeyboardInterrupt:
- print("Ctrl + C : Stop Training")
- sys.exit(1)
- except MemoryError:
- print("Memory Error : Stop Training")
- sys.exit(12)
- except ValueError:
- print("Value Error : Stop Training")
- sys.exit(11)
- except Exception as e:
- print(e)
- sys.exit(10)
-
- def __del__(self):
- del self.model
- del self.loss
- del self.n_particles
- del self.particles
- del self.c0
- del self.c1
- del self.w_min
- del self.w_max
- del self.negative_swarm
- del self.avg_score
-
- gc.collect()
- tf.keras.backend.reset_uids()
- tf.keras.backend.clear_session()
-
- def set_shape(self, weights: list):
- """
- 가중치의 shape을 설정
-
- Args:
- weights (list): keras model의 가중치
- """
- self.shape = [layer.shape for layer in weights]
-
- def get_shape(self):
- return self.shape
-
- def _encode(self, weights: list):
- """
- 가중치를 1차원으로 풀어서 반환
-
- Args:
- weights (list) : keras model의 가중치
- Returns:
- (numpy array) : 가중치 - 1차원으로 풀어서 반환
- (list) : 가중치의 원본 shape
- (list) : 가중치의 원본 shape의 길이
- """
- w_gpu = np.array([])
- for layer in weights:
- w_tmp = layer.reshape(-1)
- w_gpu = np.append(w_gpu, w_tmp)
-
- return w_gpu
-
- def _decode(self, weight: np.ndarray):
- """
- _encode 로 인코딩된 가중치를 원본 shape으로 복원
- 파라미터는 encode의 리턴값을 그대로 사용을 권장
-
- Args:
- weight (numpy array): 가중치 - 1차원으로 풀어서 반환
- shape (list): 가중치의 원본 shape
- length (list): 가중치의 원본 shape의 길이
- Returns:
- (list) : 가중치 원본 shape으로 복원
- """
- weights = []
- start = 0
- for i in range(len(self.shape)):
- end = start + np.prod(self.shape[i])
- w_ = weight[start:end]
- w_ = np.reshape(w_, self.shape[i])
- weights.append(w_)
- start = end
-
- del start, end, w_
- del weight
-
- return weights
-
- def _f(self, x, y, weights):
- """
- EBPSO의 목적함수 (예상)
-
- Args:
- x (list): 입력 데이터
- y (list): 출력 데이터
- weights (list): 가중치
-
- Returns:
- (float): 목적 함수 값
- """
- self.model.set_weights(weights)
- score = self.model.evaluate(x, y, verbose=0) # type: ignore
- if self.renewal == "loss":
- score_ = score[0]
- elif self.renewal == "acc":
- score_ = score[1]
- elif self.renewal == "mse":
- score_ = score[2]
-
- if score_ > 0:
- return 1 / (1 + score_)
- else:
- return 1 + np.abs(score_)
-
- def __weight_range(self):
- """
- 가중치의 범위를 반환
-
- Returns:
- (float): 가중치의 최소값
- (float): 가중치의 최대값
- """
- w_ = self._encode(self.model.get_weights())
- # w_, w_s, w_l = self._encode(Particle.g_best_weights)
- weight_min = np.min(w_)
- weight_max = np.max(w_)
-
- del w_
-
- return weight_min, weight_max
-
- class batch_generator:
- def __init__(self, x, y, batch_size: int = 0):
- self.index = 0
- self.x = x
- self.y = y
- self.set_batch_size(batch_size)
-
- def next(self):
- self.index += 1
- if self.index > self.max_index:
- self.index = 0
- self.dataset = self.__get_batch_slice(self.batch_size)
- return self.dataset[self.index - 1][0], self.dataset[self.index - 1][1]
-
- def get_length(self):
- return self.get_max_index()
-
- def get_max_index(self):
- return self.max_index
-
- def get_index(self):
- return self.index
-
- def set_index(self, index):
- self.index = index
-
- def get_batch_size(self):
- return self.batch_size
-
- def set_batch_size(self, batch_size: int = 0):
- if batch_size == -1 or batch_size > len(self.x):
- batch_size = len(self.x)
- elif batch_size == 0:
- batch_size = len(self.x) // 10
-
- self.batch_size = batch_size
-
- print(f"batch size : {self.batch_size}")
- self.dataset = self.__get_batch_slice(self.batch_size)
- self.max_index = len(self.dataset)
-
- def __get_batch_slice(self, batch_size):
- return list(
- tf.data.Dataset.from_tensor_slices((self.x, self.y))
- .shuffle(len(self.x))
- .batch(batch_size)
+ if (
+ isinstance(initial_position_noise, bool)
+ or not isinstance(initial_position_noise, (int, float))
+ or not math.isfinite(initial_position_noise)
+ or initial_position_noise < 0.0
+ ):
+ raise ValueError(
+ "initial_position_noise must be a finite nonnegative number"
)
- def get_dataset(self):
- return self.dataset
+ if seed is not None:
+ if isinstance(seed, bool) or not isinstance(seed, int) or seed < 0:
+ raise ValueError("seed must be a non-negative integer")
+
+ if (
+ isinstance(convergence_patience, bool)
+ or not isinstance(convergence_patience, int)
+ or convergence_patience <= 0
+ ):
+ raise ValueError("convergence_patience must be a positive integer")
+
+ if (
+ isinstance(convergence_min_delta, bool)
+ or not isinstance(convergence_min_delta, (int, float))
+ or not math.isfinite(convergence_min_delta)
+ or convergence_min_delta < 0
+ ):
+ raise ValueError(
+ "convergence_min_delta must be a finite nonnegative number"
+ )
+
+ if convergence_monitor not in ("loss", "acc", "accuracy", "mse"):
+ raise ValueError(
+ "convergence_monitor must be one of 'loss', 'acc', 'accuracy', 'mse'"
+ )
+
+ if (
+ isinstance(refinement_epochs, bool)
+ or not isinstance(refinement_epochs, int)
+ or refinement_epochs < 0
+ ):
+ raise ValueError("refinement_epochs must be a non-negative integer")
+
+ if (
+ isinstance(refinement_lr, bool)
+ or not isinstance(refinement_lr, (int, float))
+ or not math.isfinite(refinement_lr)
+ or float(refinement_lr) <= 0.0
+ ):
+ raise ValueError("refinement_lr must be a positive finite float")
+
+ self.device = resolve_device(device)
+ self.task = task
+
+ self.model = copy.deepcopy(model)
+ self.eval_model = copy.deepcopy(model).to(self.device)
+ self.eval_loss = copy.deepcopy(loss).to(self.device)
+
+ if self.device.type == "mps":
+ self.eval_model = self.eval_model.to(dtype=torch.float32)
+ if hasattr(self.eval_loss, "to"):
+ self.eval_loss = self.eval_loss.to(dtype=torch.float32)
+
+ self.eval_model.eval()
+ if hasattr(self.eval_loss, "eval"):
+ self.eval_loss.eval()
+
+ self.codec = ParameterCodec(self.eval_model)
+ self._base_vector = self.codec.encode(self.eval_model).clone().detach()
+ base_vector = self._base_vector.clone()
+
+ self.n_particles = n_particles
+ self.negative_swarm = float(negative_swarm)
+ self.mutation_swarm = float(mutation_swarm)
+ self.particle_min = float(particle_min) if particle_min is not None else None
+ self.particle_max = float(particle_max) if particle_max is not None else None
+ self.velocity_limit_ratio = (
+ float(velocity_limit_ratio) if velocity_limit_ratio is not None else None
+ )
+ self.boundary_strategy = boundary_strategy
+ self.initial_position_noise = float(initial_position_noise)
+
+ if (
+ self.velocity_limit_ratio is not None
+ and self.particle_min is not None
+ and self.particle_max is not None
+ ):
+ self.velocity_limit = float(
+ self.velocity_limit_ratio * (self.particle_max - self.particle_min)
+ )
+ else:
+ self.velocity_limit = None
+
+ self.seed = seed
+ self.renewal = "acc"
+ self.fitness_size = fitness_size
+ self.convergence_patience = convergence_patience
+ self.convergence_min_delta = float(convergence_min_delta)
+ self.convergence_monitor = convergence_monitor
+ self.refinement_epochs = refinement_epochs
+ self.refinement_lr = float(refinement_lr)
+
+ self._method_selector = method if isinstance(method, str) else method.metadata.title
+ self._initialization_selector = initialization if isinstance(initialization, str) else initialization.metadata.title
+ self._evaluation_selector = evaluation if isinstance(evaluation, str) else evaluation.metadata.title
+ self._convergence_selector = convergence if isinstance(convergence, str) else convergence.metadata.title
+ self._refinement_selector = refinement if isinstance(refinement, str) else refinement.metadata.title
+
+ # Split stage options cleanly to prevent cross-stage consumption
+ movement_opts = dict(method_options or {})
+ if c0 is not None:
+ movement_opts["c0"] = c0
+ if c1 is not None:
+ movement_opts["c1"] = c1
+ if w_min is not None:
+ movement_opts["w_min"] = w_min
+ if w_max is not None:
+ movement_opts["w_max"] = w_max
+ if moment_blend is not None:
+ movement_opts["moment_blend"] = moment_blend
+ if moment_beta1 is not None:
+ movement_opts["moment_beta1"] = moment_beta1
+ if moment_beta2 is not None:
+ movement_opts["moment_beta2"] = moment_beta2
+ if moment_step_size is not None:
+ movement_opts["moment_step_size"] = moment_step_size
+ if moment_epsilon is not None:
+ movement_opts["moment_epsilon"] = moment_epsilon
+
+ init_opts = {}
+ if self._initialization_selector not in ("uniform", "Uniform Bounded Space Initialization"):
+ if initial_position_noise != 0.05:
+ init_opts["noise"] = initial_position_noise
+
+ eval_opts = {}
+ if self._evaluation_selector not in ("full", "Full Dataset Evaluation"):
+ if fitness_size is not None:
+ eval_opts["fitness_size"] = fitness_size
+
+ conv_opts = {}
+ if self._convergence_selector not in ("none", "No Convergence Action"):
+ conv_opts = {
+ "patience": convergence_patience,
+ "min_delta": convergence_min_delta,
+ "monitor": convergence_monitor,
+ }
+
+ refine_opts = {}
+ if self._refinement_selector not in ("none", "No Refinement"):
+ refine_opts = {
+ "epochs": refinement_epochs,
+ "lr": refinement_lr,
+ }
+ # Handle custom movement plugin conflict validation
+ if isinstance(method, MovementPlugin):
+ for k in ("c0", "c1", "w_min", "w_max"):
+ if getattr(method, k, None) is not None and movement_opts.get(k) is not None:
+ if float(getattr(method, k)) != float(movement_opts[k]):
+ raise ValueError(
+ f"Conflicting parameter '{k}' provided for preconfigured custom movement instance"
+ )
+
+ self.movement_plugin: MovementPlugin = get_plugin("movement", method, movement_opts) # type: ignore
+ self.initialization_plugin: InitializationPlugin = get_plugin(
+ "initialization", initialization, init_opts
+ ) # type: ignore
+ self.evaluation_plugin: EvaluationPlugin = get_plugin(
+ "evaluation", evaluation, eval_opts
+ ) # type: ignore
+ self.convergence_plugin: ConvergencePlugin = get_plugin(
+ "convergence", convergence, conv_opts
+ ) # type: ignore
+ self.refinement_plugin: RefinementPlugin = get_plugin(
+ "refinement", refinement, refine_opts
+ ) # type: ignore
+
+ # Resolve scalar parameter attributes from movement plugin (or None if irrelevant)
+ self.c0 = (
+ float(getattr(self.movement_plugin, "c0"))
+ if hasattr(self.movement_plugin, "c0") and getattr(self.movement_plugin, "c0", None) is not None
+ else None
+ )
+ self.c1 = (
+ float(getattr(self.movement_plugin, "c1"))
+ if hasattr(self.movement_plugin, "c1") and getattr(self.movement_plugin, "c1", None) is not None
+ else None
+ )
+ self.w_min = (
+ float(getattr(self.movement_plugin, "w_min"))
+ if hasattr(self.movement_plugin, "w_min") and getattr(self.movement_plugin, "w_min", None) is not None
+ else None
+ )
+ self.w_max = (
+ float(getattr(self.movement_plugin, "w_max"))
+ if hasattr(self.movement_plugin, "w_max") and getattr(self.movement_plugin, "w_max", None) is not None
+ else None
+ )
+
+ self.moment_blend = (
+ float(getattr(self.movement_plugin, "moment_blend"))
+ if hasattr(self.movement_plugin, "moment_blend")
+ else (float(moment_blend) if moment_blend is not None else 0.0)
+ )
+ self.moment_beta1 = (
+ float(getattr(self.movement_plugin, "moment_beta1"))
+ if hasattr(self.movement_plugin, "moment_beta1")
+ else (float(moment_beta1) if moment_beta1 is not None else 0.9)
+ )
+ self.moment_beta2 = (
+ float(getattr(self.movement_plugin, "moment_beta2"))
+ if hasattr(self.movement_plugin, "moment_beta2")
+ else (float(moment_beta2) if moment_beta2 is not None else 0.999)
+ )
+ self.moment_step_size = (
+ float(getattr(self.movement_plugin, "moment_step_size"))
+ if hasattr(self.movement_plugin, "moment_step_size")
+ else (float(moment_step_size) if moment_step_size is not None else 1.0)
+ )
+ self.moment_epsilon = (
+ float(getattr(self.movement_plugin, "moment_epsilon"))
+ if hasattr(self.movement_plugin, "moment_epsilon")
+ else (float(moment_epsilon) if moment_epsilon is not None else 1e-8)
+ )
+
+ # Validate stage/option combinations
+ eval_title = self.evaluation_plugin.metadata.title
+ if self.fitness_size is not None and eval_title != "Fixed Subset Evaluation":
+ raise ValueError("fitness_size is only valid with evaluation='fixed_subset'")
+
+ refine_title = self.refinement_plugin.metadata.title
+ if self.refinement_epochs > 0 and refine_title == "No Refinement":
+ raise ValueError("refinement_epochs > 0 is valid only with refinement='adam'")
+
+ mv_title = self.movement_plugin.metadata.title
+ if self.negative_swarm != 0.0 and mv_title in (
+ "Fully Informed Particle Swarm (FIPS)",
+ "Comprehensive Learning PSO (CLPSO)",
+ "Bare Bones PSO",
+ "Quantum PSO",
+ ):
+ raise ValueError(
+ f"negative_swarm is unsupported for movement method '{mv_title}'"
+ )
+
+ if self.mutation_swarm != 0.0 and mv_title in (
+ "Bare Bones PSO",
+ "Quantum PSO",
+ ):
+ raise ValueError(f"mutation_swarm is unsupported for {mv_title}")
+
+ if self.velocity_limit is not None and mv_title in (
+ "Bare Bones PSO",
+ "Quantum PSO",
+ ):
+ raise ValueError(f"velocity_limit is unsupported for {mv_title}")
+
+ self._random_source = _RandomSource(seed=self.seed, device=self.device)
+ self.generator = self._random_source.cpu_generator
+
+ self._global_best_score: tuple[float, float, float] | None = None
+ self._global_best_weights: torch.Tensor | None = None
+ self.particles: list[Particle] = []
+
+ def get_best_model(self) -> nn.Module | None:
+ """
+ Returns a fresh deepcopied eval-mode nn.Module on selected device with best parameters,
+ or None if optimization has not been run.
+ """
+ if self._global_best_weights is None:
+ return None
+ best_model = copy.deepcopy(self.model).to(self.device)
+ if self.device.type == "mps":
+ best_model = best_model.to(dtype=torch.float32)
+ self.codec.apply_vector(self._global_best_weights, best_model)
+ best_model.eval()
+ return best_model
+
+ def get_best_score(self) -> tuple[float, float, float] | None:
+ """
+ Returns the best score as an immutable 3-float tuple (loss, acc, mse),
+ or None if optimization has not been run.
+ """
+ if self._global_best_score is None:
+ return None
+ return (
+ float(self._global_best_score[0]),
+ float(self._global_best_score[1]),
+ float(self._global_best_score[2]),
+ )
+
+ def get_best_state_dict(self) -> collections.OrderedDict[str, torch.Tensor] | None:
+ """
+ Returns a defensive CPU-cloned state dict of the best model,
+ or None if optimization has not been run.
+ """
+ if self._global_best_weights is None:
+ return None
+ return self.codec.to_state_dict(self._global_best_weights, self.eval_model)
+ def evaluate(
+ self,
+ x: torch.Tensor,
+ y: torch.Tensor,
+ *,
+ batch_size: int | None = None,
+ ) -> tuple[float, float, float]:
+ """
+ Evaluates the current best model weights on input data (x, y) with aggregate metric semantics.
+ Validates input tensor shapes and types. Mutates no state and produces no artifacts.
+ """
+ if self._global_best_weights is None:
+ raise RuntimeError("Optimization has not been run or best weights are unavailable")
+
+ if not isinstance(x, torch.Tensor) or not isinstance(y, torch.Tensor):
+ raise TypeError("x and y must be torch.Tensor instances")
+
+ if x.ndim == 0 or y.ndim == 0:
+ raise ValueError("x and y must have a leading dimension (ndim >= 1)")
+
+ len_x = x.shape[0]
+ len_y = y.shape[0]
+ if len_x != len_y:
+ raise ValueError(f"x and y leading dimensions must match: {len_x} != {len_y}")
+ if len_x == 0:
+ raise ValueError("x and y leading dimensions must be nonzero")
+
+ if batch_size is not None:
+ if (
+ isinstance(batch_size, bool)
+ or not isinstance(batch_size, int)
+ or batch_size <= 0
+ ):
+ raise ValueError("batch_size must be a positive integer")
+
+ dtype_model = next(self.eval_model.parameters()).dtype
+ x_dev = x.to(device=self.device, dtype=dtype_model)
+
+ if self.task == "multiclass":
+ if y.ndim > 1 and y.shape[-1] > 1:
+ y_dev = y.to(device=self.device, dtype=dtype_model)
+ else:
+ y_dev = y.to(device=self.device, dtype=torch.int64)
+ elif self.task in ("binary", "regression"):
+ y_dev = y.to(device=self.device, dtype=dtype_model)
+
+ raw_score = self._evaluate_aggregate_score(
+ self._global_best_weights, x_dev, y_dev, batch_size=batch_size
+ )
+ return _validate_score(raw_score, particle_idx=-1, iteration=-1)
+
+ def _compute_batch_loss(
+ self, out: torch.Tensor, y_batch: torch.Tensor
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ """
+ Normalizes targets and computes (raw_loss, loss_tensor).
+ """
+ batch_size = out.shape[0]
+ if self.task in ("binary", "regression"):
+ if y_batch.numel() != out.numel():
+ raise ValueError(
+ f"Target element count ({y_batch.numel()}) does not match model output element count ({out.numel()}) for task '{self.task}'."
+ )
+ target_norm = y_batch.to(device=out.device, dtype=out.dtype).reshape_as(out)
+ raw_loss = self.eval_loss(out, target_norm)
+ elif self.task == "multiclass":
+ if out.ndim < 2:
+ raise ValueError(
+ f"Multiclass model output must have rank >= 2 (logits of shape [batch_size, num_classes]), got shape {tuple(out.shape)}."
+ )
+ if tuple(y_batch.shape) == tuple(out.shape):
+ target_norm = y_batch.to(device=out.device, dtype=out.dtype)
+ elif y_batch.numel() == batch_size:
+ target_norm = y_batch.to(
+ device=out.device, dtype=torch.int64
+ ).reshape(-1)
+ else:
+ raise ValueError(
+ f"Multiclass target shape {tuple(y_batch.shape)} (numel={y_batch.numel()}) is incompatible with model output shape {tuple(out.shape)} (batch_size={batch_size})."
+ )
+ raw_loss = self.eval_loss(out, target_norm)
+ else:
+ raise ValueError(f"Unknown task: {self.task}")
+
+ if not isinstance(raw_loss, torch.Tensor):
+ raise TypeError(
+ f"Loss function must return a torch.Tensor, got {type(raw_loss).__name__}"
+ )
+
+ loss_tensor = (
+ raw_loss.mean() if raw_loss.numel() > 1 else raw_loss.reshape(())
+ )
+ return raw_loss, loss_tensor
+
+ def _compute_batch_metrics(
+ self, out: torch.Tensor, y_batch: torch.Tensor
+ ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+ """
+ Computes (raw_loss, loss_tensor, acc_tensor, mse_tensor) for model output and target batch.
+ """
+ batch_size = out.shape[0]
+ raw_loss, loss_tensor = self._compute_batch_loss(out, y_batch)
+
+ if self.task in ("binary", "regression"):
+ target_norm = y_batch.to(device=out.device, dtype=out.dtype).reshape_as(out)
+ if self.task == "binary":
+ if isinstance(self.eval_loss, nn.BCEWithLogitsLoss):
+ probs = torch.sigmoid(out)
+ else:
+ probs = out
+ preds = (probs >= 0.5).to(out.dtype)
+ acc_tensor = (preds == target_norm).to(dtype=out.dtype).mean()
+ mse_tensor = torch.mean((probs - target_norm) ** 2)
+ else:
+ acc_tensor = torch.tensor(0.0, device=out.device, dtype=out.dtype)
+ mse_tensor = torch.mean((out - target_norm) ** 2)
+
+ elif self.task == "multiclass":
+ if tuple(y_batch.shape) == tuple(out.shape):
+ target_norm = y_batch.to(device=out.device, dtype=out.dtype)
+ target_classes = torch.argmax(target_norm, dim=-1)
+ y_one_hot = target_norm
+ else:
+ target_norm = y_batch.to(
+ device=out.device, dtype=torch.int64
+ ).reshape(-1)
+ target_classes = target_norm
+ num_classes = out.shape[-1]
+ y_one_hot = torch.nn.functional.one_hot(
+ target_classes, num_classes=num_classes
+ ).to(dtype=out.dtype)
+
+ probs = torch.softmax(out, dim=-1)
+ preds = torch.argmax(out, dim=-1)
+ acc_tensor = (preds == target_classes).to(dtype=out.dtype).mean()
+ mse_tensor = torch.mean((probs - y_one_hot) ** 2)
+ else:
+ raise ValueError(f"Unknown task: {self.task}")
+
+ return raw_loss, loss_tensor, acc_tensor, mse_tensor
+
+ def _evaluate_batch_tensors(
+ self, x_batch: torch.Tensor, y_batch: torch.Tensor
+ ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """
+ Evaluates batch metrics on current installed model parameters.
+ Returns 0D device tensors (loss, acc, mse).
+ """
+ out = self.eval_model(x_batch)
+ if not isinstance(out, torch.Tensor) or out.ndim < 1:
+ raise ValueError("Model output must be a torch.Tensor with rank >= 1.")
+
+ batch_size = x_batch.shape[0]
+ if out.shape[0] != batch_size:
+ raise ValueError(
+ f"Model output leading dimension ({out.shape[0]}) does not match batch size ({batch_size})."
+ )
+
+ _, loss_t, acc_t, mse_t = self._compute_batch_metrics(out, y_batch)
+ return loss_t, acc_t, mse_t
+
+ def _evaluate_batch(
+ self, position: torch.Tensor, x_batch: torch.Tensor, y_batch: torch.Tensor
+ ) -> tuple[float, float, float]:
+ """
+ Scalar tuple evaluation wrapper.
+ """
+ self.codec.apply_vector(position, self.eval_model)
+ with torch.inference_mode():
+ t_loss, t_acc, t_mse = self._evaluate_batch_tensors(x_batch, y_batch)
+ return (t_loss.item(), t_acc.item(), t_mse.item())
+
+ def _evaluate_aggregate_score(
+ self,
+ position: torch.Tensor,
+ x_data: torch.Tensor,
+ y_data: torch.Tensor,
+ batch_size: int | None = None,
+ ) -> tuple[float, float, float]:
+ """
+ Evaluates aggregate score across all batches of x_data, y_data for a given position.
+ """
+ self.codec.apply_vector(position, self.eval_model)
+ n_samples = x_data.shape[0]
+ effective_batch_size = (
+ n_samples
+ if batch_size is None or batch_size >= n_samples
+ else batch_size
+ )
+
+ acc_dtype = self.codec.dtype
+ batch_loss_sum = torch.tensor(0.0, device=self.device, dtype=acc_dtype)
+ batch_acc_sum = torch.tensor(0.0, device=self.device, dtype=acc_dtype)
+ batch_mse_sum = torch.tensor(0.0, device=self.device, dtype=acc_dtype)
+ total_samples = 0
+
+ with torch.inference_mode():
+ for start in range(0, n_samples, effective_batch_size):
+ end = min(start + effective_batch_size, n_samples)
+ batch_len = end - start
+ x_b = x_data[start:end]
+ y_b = y_data[start:end]
+ t_loss, t_acc, t_mse = self._evaluate_batch_tensors(x_b, y_b)
+ batch_loss_sum += t_loss * batch_len
+ batch_acc_sum += t_acc * batch_len
+ batch_mse_sum += t_mse * batch_len
+ total_samples += batch_len
+
+ agg_tensor = torch.stack([
+ batch_loss_sum / total_samples,
+ batch_acc_sum / total_samples,
+ batch_mse_sum / total_samples,
+ ])
+ agg_cpu = agg_tensor.detach().cpu().tolist()
+ return (float(agg_cpu[0]), float(agg_cpu[1]), float(agg_cpu[2]))
+
+ def _optimize(
+ self,
+ x_fitness: torch.Tensor,
+ y_fitness: torch.Tensor,
+ fit_context: FitContext,
+ *,
+ epochs: int = 10,
+ batch_size: int | None = None,
+ renewal: str = "acc",
+ checkpoint_interval: int | None = None,
+ ) -> tuple[
+ tuple[float, float, float],
+ list[dict[str, Any]],
+ dict[int, torch.Tensor],
+ ]:
+ n_samples = x_fitness.shape[0]
+ effective_batch_size = (
+ n_samples
+ if batch_size is None or batch_size >= n_samples
+ else batch_size
+ )
+
+ history: list[dict[str, Any]] = []
+ checkpoint_snapshots: dict[int, torch.Tensor] = {}
+
+ for epoch in range(epochs):
+ epoch_num = epoch + 1
+ if self.w_min is not None and self.w_max is not None:
+ if epochs <= 2:
+ w = self.w_max
+ else:
+ w_raw = self.w_max - (self.w_max - self.w_min) * (epoch / (epochs - 2))
+ w = max(self.w_min, min(self.w_max, w_raw))
+ else:
+ w = 0.0
+
+ epoch_scores = torch.zeros(
+ (self.n_particles, 3), device=self.device, dtype=self.codec.dtype
+ )
+
+ for i, p in enumerate(self.particles):
+ self.codec.apply_vector(p.position, self.eval_model)
+
+ batch_loss_sum = torch.tensor(
+ 0.0, device=self.device, dtype=self.codec.dtype
+ )
+ batch_acc_sum = torch.tensor(
+ 0.0, device=self.device, dtype=self.codec.dtype
+ )
+ batch_mse_sum = torch.tensor(
+ 0.0, device=self.device, dtype=self.codec.dtype
+ )
+ total_samples = 0
+
+ with torch.inference_mode():
+ for start in range(0, n_samples, effective_batch_size):
+ end = min(start + effective_batch_size, n_samples)
+ batch_len = end - start
+
+ x_batch = x_fitness[start:end]
+ y_batch = y_fitness[start:end]
+
+ t_loss, t_acc, t_mse = self._evaluate_batch_tensors(
+ x_batch, y_batch
+ )
+ batch_loss_sum += t_loss * batch_len
+ batch_acc_sum += t_acc * batch_len
+ batch_mse_sum += t_mse * batch_len
+ total_samples += batch_len
+
+ epoch_scores[i, 0] = batch_loss_sum / total_samples
+ epoch_scores[i, 1] = batch_acc_sum / total_samples
+ epoch_scores[i, 2] = batch_mse_sum / total_samples
+
+ cpu_scores = epoch_scores.detach().cpu().tolist()
+ pbest_improved = [False] * self.n_particles
+ pending_resets = [False] * self.n_particles
+
+ for i, p in enumerate(self.particles):
+ score = _validate_score(
+ cpu_scores[i],
+ particle_idx=i,
+ iteration=epoch_num,
+ )
+ if p.personal_best_score is None or _is_better_score(
+ score, p.personal_best_score, renewal
+ ):
+ p.personal_best_score = score
+ p.personal_best_weights = p.position.clone()
+ pbest_improved[i] = True
+
+ if _is_better_score(score, self._global_best_score, renewal):
+ self._global_best_score = score
+ self._global_best_weights = p.position.clone()
+
+ iter_ctx = IterationContext(
+ epoch=epoch_num,
+ total_epochs=epochs,
+ w=w,
+ particle_idx=i,
+ is_negative=p.negative,
+ rng=self._random_source,
+ optimizer=self,
+ )
+ should_reset = self.convergence_plugin.on_particle_evaluated(
+ i, score, pbest_improved[i], iter_ctx
+ )
+ if should_reset:
+ pending_resets[i] = True
+
+ if self._global_best_weights is None:
+ raise RuntimeError(
+ "Global best weights not set before velocity calculation"
+ )
+
+ gbest_improved = _is_better_score(
+ self._global_best_score, getattr(self, "_prev_gbest_score", None), renewal
+ )
+ self._prev_gbest_score = self._global_best_score
+
+ epoch_iter_ctx = IterationContext(
+ epoch=epoch_num,
+ total_epochs=epochs,
+ w=w,
+ particle_idx=-1,
+ is_negative=False,
+ rng=self._random_source,
+ optimizer=self,
+ )
+ stop_early = self.convergence_plugin.on_epoch_end(
+ self._global_best_score, gbest_improved, epoch_iter_ctx
+ )
+
+ if epoch < epochs - 1 and not stop_early:
+ # Build SwarmState snapshot BEFORE movement calculation
+ swarm_positions = tuple(p.position for p in self.particles)
+ swarm_velocities = tuple(p.velocity for p in self.particles)
+ swarm_pbests = tuple(
+ p.personal_best_weights if p.personal_best_weights is not None else p.position
+ for p in self.particles
+ )
+ pbest_scores_tuple = tuple(
+ p.personal_best_score
+ if p.personal_best_score is not None
+ else (float("inf"), float("-inf"), float("inf"))
+ for p in self.particles
+ )
+ swarm_state = SwarmState(
+ positions=swarm_positions,
+ velocities=swarm_velocities,
+ pbest_positions=swarm_pbests,
+ pbest_scores=pbest_scores_tuple,
+ gbest_position=self._global_best_weights.detach(),
+ gbest_score=self._global_best_score,
+ pbest_improved=tuple(pbest_improved),
+ )
+
+ self.movement_plugin.on_epoch_end(swarm_state, epoch_iter_ctx)
+
+ for i, p in enumerate(self.particles):
+ p_iter_ctx = IterationContext(
+ epoch=epoch_num,
+ total_epochs=epochs,
+ w=w,
+ particle_idx=i,
+ is_negative=p.negative,
+ rng=self._random_source,
+ optimizer=self,
+ )
+ pos_override, vel_override = self.movement_plugin.propose(
+ i, swarm_state, p_iter_ctx
+ )
+ if pos_override is not None:
+ p.velocity = torch.zeros_like(p.velocity)
+ p.position = pos_override
+ elif vel_override is not None:
+ proposed_v = vel_override
+ if (
+ self.mutation_swarm > 0.0
+ and self._random_source.bernoulli_event(
+ self.mutation_swarm
+ )
+ ):
+ proposed_v = self._random_source.uniform(
+ p.position.shape,
+ -0.2,
+ 0.2,
+ device=self.device,
+ dtype=self.codec.dtype,
+ )
+ self.movement_plugin.reset_particle_state(i)
+ if self.velocity_limit is not None:
+ proposed_v = torch.clamp(
+ proposed_v, -self.velocity_limit, self.velocity_limit
+ )
+ p.velocity = proposed_v
+ p.position = p.position + p.velocity
+
+ p.apply_boundary_strategy(
+ self.particle_min, self.particle_max, self.boundary_strategy
+ )
+
+ for i, p in enumerate(self.particles):
+ if pending_resets[i]:
+ base_vec = fit_context.base_vector
+ p.reset(base_vec, fit_context, self.initialization_plugin)
+ self.movement_plugin.reset_particle_state(i)
+ self.convergence_plugin.reset_particle(i)
+ best = self.get_best_score()
+ if best is None:
+ raise RuntimeError(
+ "Optimization epoch completed without recording a best score"
+ )
+
+ history.append(
+ {
+ "epoch": epoch_num,
+ "loss": float(best[0]),
+ "accuracy": float(best[1]),
+ "mse": float(best[2]),
+ }
+ )
+
+ if (
+ checkpoint_interval is not None
+ and epoch_num % checkpoint_interval == 0
+ ):
+ if self._global_best_weights is not None:
+ checkpoint_snapshots[epoch_num] = (
+ self._global_best_weights.detach().cpu().clone()
+ )
+
+ if stop_early:
+ break
+
+ best = self.get_best_score()
+ if best is None:
+ raise RuntimeError(
+ "Optimization completed without recording a best score"
+ )
+
+ return best, history, checkpoint_snapshots
+
+ def _refine(
+ self,
+ x_fitness: torch.Tensor,
+ y_fitness: torch.Tensor,
+ *,
+ refinement_epochs: int,
+ refinement_lr: float,
+ batch_size: int | None,
+ renewal: str,
+ ) -> None:
+ """
+ Adam local search on fitness tensors/batching.
+ """
+ if refinement_epochs <= 0 or self._global_best_weights is None:
+ return
+
+ candidate_weights = self._global_best_weights.clone()
+ self.codec.apply_vector(candidate_weights, self.eval_model)
+ self.eval_model.eval()
+
+ optimizer = torch.optim.Adam(self.eval_model.parameters(), lr=refinement_lr)
+
+ n_samples = x_fitness.shape[0]
+ effective_batch_size = (
+ n_samples
+ if batch_size is None or batch_size >= n_samples
+ else batch_size
+ )
+
+ for epoch in range(refinement_epochs):
+ for start in range(0, n_samples, effective_batch_size):
+ end = min(start + effective_batch_size, n_samples)
+ x_b = x_fitness[start:end]
+ y_b = y_fitness[start:end]
+
+ optimizer.zero_grad()
+ out = self.eval_model(x_b)
+ if not isinstance(out, torch.Tensor) or out.ndim < 1:
+ raise ValueError("Model output must be a torch.Tensor with rank >= 1.")
+ if out.shape[0] != x_b.shape[0]:
+ raise ValueError(
+ f"Model output leading dimension ({out.shape[0]}) does not match batch size ({x_b.shape[0]})."
+ )
+
+ _, batch_loss = self._compute_batch_loss(out, y_b)
+ batch_loss.backward()
+ optimizer.step()
+
+ if self.particle_min is not None and self.particle_max is not None:
+ with torch.no_grad():
+ for p in self.eval_model.parameters():
+ p.clamp_(self.particle_min, self.particle_max)
+
+ candidate_w = self.codec.encode(self.eval_model)
+ candidate_score = self._evaluate_aggregate_score(
+ candidate_w, x_fitness, y_fitness, batch_size
+ )
+ validated_score = _validate_score(
+ candidate_score, particle_idx=-1, iteration=epoch + 1
+ )
+ if _is_better_score(validated_score, self._global_best_score, renewal):
+ self._global_best_score = validated_score
+ self._global_best_weights = candidate_w.clone()
+
+ def _save_artifacts(
+ self,
+ *,
+ output_dir: str | os.PathLike,
+ epochs: int,
+ batch_size: int | None,
+ fitness_size: int | None,
+ renewal: str,
+ refinement_epochs: int = 0,
+ refinement_lr: float = 0.001,
+ validation_split: float | None,
+ val_source: str | None,
+ log_format: str,
+ checkpoint_interval: int | None,
+ save_info: bool,
+ best_score: tuple[float, float, float],
+ val_score: tuple[float, float, float] | None,
+ val_sample_count: int | None,
+ history: list[dict[str, Any]],
+ checkpoint_snapshots: dict[int, torch.Tensor],
+ ) -> None:
+ os.makedirs(output_dir, exist_ok=True)
+
+ best_state_dict = self.get_best_state_dict()
+ if best_state_dict is None:
+ raise RuntimeError(
+ "Cannot save best model because optimization state is missing"
+ )
+
+ best_checkpoint = {
+ "model_state_dict": best_state_dict,
+ "score": best_score,
+ "task": self.task,
+ "device": self.device.type,
+ "version": __version__,
+ }
+ torch.save(best_checkpoint, os.path.join(output_dir, "best_model.pt"))
+
+ if checkpoint_snapshots:
+ checkpoints_dir = os.path.join(output_dir, "checkpoints")
+ os.makedirs(checkpoints_dir, exist_ok=True)
+ for epoch_num, weights_vector in sorted(checkpoint_snapshots.items()):
+ ckpt_path = os.path.join(checkpoints_dir, f"epoch-{epoch_num}.pt")
+ ckpt_state_dict = self.codec.to_state_dict(
+ weights_vector, self.eval_model
+ )
+ ckpt_payload = {
+ "epoch": epoch_num,
+ "model_state_dict": ckpt_state_dict,
+ "score": (
+ history[epoch_num - 1]["loss"],
+ history[epoch_num - 1]["accuracy"],
+ history[epoch_num - 1]["mse"],
+ ),
+ "task": self.task,
+ "device": self.device.type,
+ "version": __version__,
+ }
+ torch.save(ckpt_payload, ckpt_path)
+
+ if log_format == "csv":
+ csv_path = os.path.join(output_dir, "history.csv")
+ with open(csv_path, "w", newline="", encoding="utf-8") as f:
+ writer = csv.DictWriter(
+ f, fieldnames=["epoch", "loss", "accuracy", "mse"]
+ )
+ writer.writeheader()
+ writer.writerows(history)
+ elif log_format == "tensorboard":
+ from torch.utils.tensorboard import SummaryWriter
+
+ tb_dir = os.path.join(output_dir, "tensorboard")
+ writer = SummaryWriter(log_dir=tb_dir)
+ for row in history:
+ ep = row["epoch"]
+ writer.add_scalar("loss/train", row["loss"], ep)
+ writer.add_scalar("accuracy/train", row["accuracy"], ep)
+ writer.add_scalar("mse/train", row["mse"], ep)
+ writer.close()
+
+ if save_info:
+ loss_name = getattr(
+ self.eval_loss, "__class__", type(self.eval_loss)
+ ).__name__
+ run_info = {
+ "version": __version__,
+ "task": self.task,
+ "device": self.device.type,
+ "loss_function": loss_name,
+ "config": {
+ "method": self._method_selector,
+ "initialization": self._initialization_selector,
+ "evaluation": self._evaluation_selector,
+ "convergence": self._convergence_selector,
+ "refinement": self._refinement_selector,
+ "plugins": {
+ "movement": {
+ "title": self.movement_plugin.metadata.title,
+ "source": self.movement_plugin.metadata.source,
+ "gradient_required": self.movement_plugin.metadata.gradient_required,
+ "fidelity": self.movement_plugin.metadata.fidelity,
+ "options": self.movement_plugin.get_options(),
+ },
+ "initialization": {
+ "title": self.initialization_plugin.metadata.title,
+ "source": self.initialization_plugin.metadata.source,
+ "gradient_required": self.initialization_plugin.metadata.gradient_required,
+ "fidelity": self.initialization_plugin.metadata.fidelity,
+ "options": self.initialization_plugin.get_options(),
+ },
+ "evaluation": {
+ "title": self.evaluation_plugin.metadata.title,
+ "source": self.evaluation_plugin.metadata.source,
+ "gradient_required": self.evaluation_plugin.metadata.gradient_required,
+ "fidelity": self.evaluation_plugin.metadata.fidelity,
+ "options": self.evaluation_plugin.get_options(),
+ },
+ "convergence": {
+ "title": self.convergence_plugin.metadata.title,
+ "source": self.convergence_plugin.metadata.source,
+ "gradient_required": self.convergence_plugin.metadata.gradient_required,
+ "fidelity": self.convergence_plugin.metadata.fidelity,
+ "options": self.convergence_plugin.get_options(),
+ },
+ "refinement": {
+ "title": self.refinement_plugin.metadata.title,
+ "source": self.refinement_plugin.metadata.source,
+ "gradient_required": self.refinement_plugin.metadata.gradient_required,
+ "fidelity": self.refinement_plugin.metadata.fidelity,
+ "options": self.refinement_plugin.get_options(),
+ },
+ },
+ "n_particles": self.n_particles,
+ "c0": self.c0,
+ "c1": self.c1,
+ "w_min": self.w_min,
+ "w_max": self.w_max,
+ "negative_swarm": self.negative_swarm,
+ "mutation_swarm": self.mutation_swarm,
+ "particle_min": self.particle_min,
+ "particle_max": self.particle_max,
+ "velocity_limit_ratio": self.velocity_limit_ratio,
+ "boundary_strategy": self.boundary_strategy,
+ "initial_position_noise": self.initial_position_noise,
+ "seed": self.seed,
+ "fitness_size": fitness_size,
+ "convergence_patience": self.convergence_patience,
+ "convergence_min_delta": self.convergence_min_delta,
+ "convergence_monitor": self.convergence_monitor,
+ "moment_blend": self.moment_blend,
+ "moment_beta1": self.moment_beta1,
+ "moment_beta2": self.moment_beta2,
+ "moment_step_size": self.moment_step_size,
+ "moment_epsilon": self.moment_epsilon,
+ "epochs": epochs,
+ "batch_size": batch_size,
+ "renewal": renewal,
+ "refinement_epochs": refinement_epochs,
+ "refinement_lr": refinement_lr,
+ "validation_source": val_source,
+ "validation_split": validation_split,
+ "output_dir": str(output_dir),
+ "log_format": log_format,
+ "checkpoint_interval": checkpoint_interval,
+ "save_info": save_info,
+ },
+ "best_training_score": [float(x) for x in best_score],
+ "validation_score": (
+ [float(x) for x in val_score] if val_score is not None else None
+ ),
+ "validation_source": val_source,
+ "validation_sample_count": val_sample_count,
+ }
+ with open(os.path.join(output_dir, "run.json"), "w", encoding="utf-8") as f:
+ json.dump(run_info, f, indent=2)
def fit(
self,
- x,
- y,
- **kwargs,
- ):
- """
- # Args:
- x : numpy array,
- y : numpy array,
- epochs : int,
- log : int - 0 : log 기록 안함, 1 : csv, 2 : tensorboard,
- save_info : bool - 종료시 학습 정보 저장 여부 default : False,
- save_path : str - ex) "./result",
- renewal : str ex) "acc" or "loss" or "mse",
- check_point : int - 저장할 위치 - None : 저장 안함
- batch_size : int - batch size default : None => len(x) // 10
- batch_size > len(x) : auto max batch size
- validate_data : tuple - (x, y) default : None => (x, y)
- back_propagation : bool - True : back propagation, False : not back propagation default : False
- weight_reduction : int - 가중치 감소 초기화 주기 default : None => epochs
- """
- try:
- epochs = kwargs.get("epochs", 10)
- log = kwargs.get("log", 0)
- log_name = kwargs.get("log_name", None)
- save_info = kwargs.get("save_info", False)
- renewal = kwargs.get("renewal", "acc")
- check_point = kwargs.get("check_point", None)
- batch_size = kwargs.get("batch_size", None)
- validate_data = kwargs.get("validate_data", None)
- validation_split = kwargs.get("validation_split", None)
- back_propagation = kwargs.get("back_propagation", False)
- weight_reduction = kwargs.get("weight_reduction", None)
+ x: torch.Tensor,
+ y: torch.Tensor,
+ *,
+ epochs: int = 10,
+ batch_size: int | None = None,
+ fitness_size: int | None = None,
+ renewal: str = "acc",
+ refinement_epochs: int = 0,
+ refinement_lr: float = 0.001,
+ validation_data: tuple[torch.Tensor, torch.Tensor] | None = None,
+ validation_split: float | None = None,
+ output_dir: str | os.PathLike | None = None,
+ log_format: Literal["none", "csv", "tensorboard"] = "none",
+ checkpoint_interval: int | None = None,
+ save_info: bool = False,
+ ) -> tuple[float, float, float]:
+ if not isinstance(x, torch.Tensor) or not isinstance(y, torch.Tensor):
+ raise TypeError("x and y must be torch.Tensor instances")
- if x.shape[0] != y.shape[0]:
- raise ValueError("x, y shape error")
+ if x.ndim == 0 or y.ndim == 0:
+ raise ValueError("x and y must have a leading dimension (ndim >= 1)")
- if save_info is None:
- save_info = False
+ len_x = x.shape[0]
+ len_y = y.shape[0]
+ if len_x != len_y:
+ raise ValueError(f"x and y leading dimensions must match: {len_x} != {len_y}")
+ if len_x == 0:
+ raise ValueError("x and y leading dimensions must be nonzero")
- if log not in [0, 1, 2]:
- raise ValueError(
- """log not in [0, 1, 2]
- 0 : log 기록 안함
- 1 : csv
- 2 : tensorboard
- """
- )
-
- if renewal is None:
- renewal = "loss"
-
- elif renewal not in ["acc", "loss", "mse"]:
- raise ValueError("renewal not in ['acc', 'loss', 'mse']")
+ if isinstance(epochs, bool) or not isinstance(epochs, int) or epochs <= 0:
+ raise ValueError("epochs must be a positive integer")
+ if batch_size is not None:
if (
- validate_data is not None
- and validate_data[0].shape[0] != validate_data[1].shape[0]
+ isinstance(batch_size, bool)
+ or not isinstance(batch_size, int)
+ or batch_size <= 0
):
- raise ValueError("validate_data shape error")
- else:
- validate_data = [x, y]
-
- if validation_split is not None:
- if validation_split < 0 or validation_split > 1:
- raise ValueError("validation_split not in [0, 1]")
-
- [x, validate_data[0], y, validate_data[1]] = train_test_split(
- x, y, test_size=validation_split, shuffle=True
- )
-
- if batch_size is not None and batch_size < 1:
- raise ValueError("batch_size < 1")
-
- if batch_size is None or batch_size > len(x):
- batch_size = len(x)
-
- if weight_reduction == None:
- weight_reduction = epochs
-
- except ValueError as ve:
- print(ve)
- sys.exit(11)
- except Exception as e:
- print(e)
- sys.exit(10)
+ raise ValueError("batch_size must be a positive integer")
+ if renewal not in ("acc", "loss", "mse"):
+ raise ValueError("renewal must be one of 'acc', 'loss', 'mse'")
self.renewal = renewal
- try:
- if log_name is None:
- log_name = "fit"
- self.log_path = f"logs/{log_name}/{self.day}"
- if log == 2:
- assert log_name is not None, "log_name is None"
+ if (
+ isinstance(refinement_epochs, bool)
+ or not isinstance(refinement_epochs, int)
+ or refinement_epochs < 0
+ ):
+ raise ValueError("refinement_epochs must be a non-negative integer")
- train_log_dir = self.log_path + "/train"
- for i in range(self.n_particles):
- self.train_summary_writer[i] = tf.summary.create_file_writer(
- train_log_dir + f"/{i}"
- )
- port = find_free_port()
- tensorboard_precess = subprocess.Popen(
- [
- "tensorboard",
- "--logdir",
- self.log_path,
- "--port",
- str(port),
- ]
- )
- tensorboard_url = f"http://localhost:{port}"
- print(f"tensorboard url : {tensorboard_url}")
- atexit.register(tensorboard_precess.kill)
- elif check_point is not None or log == 1:
- if not os.path.exists(self.log_path):
- os.makedirs(self.log_path, exist_ok=True)
- except ValueError as ve:
- print(ve)
- sys.exit(11)
- except Exception as e:
- print(e)
- sys.exit(10)
+ if (
+ isinstance(refinement_lr, bool)
+ or not isinstance(refinement_lr, (int, float))
+ or not math.isfinite(refinement_lr)
+ or float(refinement_lr) <= 0.0
+ ):
+ raise ValueError("refinement_lr must be a positive finite float")
- try:
- dataset = self.batch_generator(x, y, batch_size=batch_size)
+ if log_format not in ("none", "csv", "tensorboard"):
+ raise ValueError("log_format must be one of 'none', 'csv', 'tensorboard'")
- if back_propagation:
- model_ = keras.models.model_from_json(self.model.to_json())
- model_.compile(
- loss=self.loss,
- optimizer="adam",
- metrics=["accuracy", "mse"],
- )
- model_.fit(x, y, epochs=1, verbose=0) # type: ignore
- score = model_.evaluate(x, y, verbose="auto")
+ if checkpoint_interval is not None:
+ if (
+ isinstance(checkpoint_interval, bool)
+ or not isinstance(checkpoint_interval, int)
+ or checkpoint_interval <= 0
+ ):
+ raise ValueError("checkpoint_interval must be a positive integer")
- Particle.g_best_score = score
+ if not isinstance(save_info, bool):
+ raise ValueError("save_info must be a boolean")
- Particle.g_best_weights = model_.get_weights()
-
- del model_
-
- print("best score init complete" + str(Particle.g_best_score))
-
- epochs_pbar = tqdm(
- range(epochs),
- desc=f"best - loss: {Particle.g_best_score[0]:.4f} - acc: {Particle.g_best_score[1]:.4f} - mse: {Particle.g_best_score[2]:.4f}",
- ascii=True,
- leave=True,
- position=0,
- )
- rng = np.random.default_rng(seed=42)
- for epoch in epochs_pbar:
- # 이번 epoch의 평균 점수
- # particle_avg = particle_sum / self.n_particles # x_j
- # particle_sum = 0
- # 각 최고 점수, 최저 loss, 최저 mse
- max_acc = 0
- min_loss = np.inf
- min_mse = np.inf
- # 한번의 실행 동안 최고 점수를 받은 파티클의 인덱스
- best_particle_index = 0
-
- part_pbar = tqdm(
- range(len(self.particles)),
- desc=f"loss: {min_loss:.4f} acc: {max_acc:.4f} mse: {min_mse:.4f}",
- ascii=True,
- leave=False,
- position=1,
- )
-
- w = (
- self.w_max
- - (self.w_max - self.w_min)
- * (epoch % weight_reduction)
- / weight_reduction
- )
-
- for i in part_pbar:
-
- for _i in tqdm(
- range(dataset.get_length()),
- desc="batch",
- ascii=True,
- leave=False,
- ):
- part_pbar.set_description(
- f"loss: {min_loss:.4f} acc: {max_acc:.4f} mse: {min_mse:.4f}"
- )
- x_batch, y_batch = dataset.next()
-
- score = self.particles[i].step(
- x_batch, y_batch, self.c0, self.c1, w, renewal=renewal
- )
-
- if renewal == "loss":
- # 최저 loss 보다 작거나 같을 경우
- if score[0] < min_loss:
- # 각 점수 갱신
- min_loss, max_acc, min_mse = score
-
- best_particle_index = i
- elif score[0] == min_loss:
- if score[1] > max_acc:
- min_loss, max_acc, min_mse = score
-
- best_particle_index = i
-
- elif renewal == "acc":
- # 최고 점수 보다 높거나 같을 경우
- if score[1] > max_acc:
- # 각 점수 갱신
- min_loss, max_acc, min_mse = score
-
- best_particle_index = i
- elif score[1] == max_acc:
- if score[2] < min_mse:
- min_loss, max_acc, min_mse = score
-
- best_particle_index = i
-
- elif renewal == "mse":
- if score[2] < min_mse:
- min_loss, max_acc, min_mse = score
-
- best_particle_index = i
- elif score[2] == min_mse:
- if score[1] > max_acc:
- min_loss, max_acc, min_mse = score
-
- best_particle_index = i
-
- if log == 2:
- with self.train_summary_writer[i].as_default():
- tf.summary.scalar("accuracy", score[1], step=epoch + 1)
- tf.summary.scalar("loss", score[0], step=epoch + 1)
- tf.summary.scalar("mse", score[2], step=epoch + 1)
-
- if log == 1:
- with open(
- f"./logs/{log_name}/{self.day}/{self.n_particles}_{epochs}_{self.c0}_{self.c1}_{self.w_min}_{renewal}.csv",
- "a",
- ) as f:
- f.write(f"{score[0]}, {score[1]}, {score[2]}")
- if i != self.n_particles - 1:
- f.write(", ")
- else:
- f.write("\n")
-
- part_pbar.refresh()
- # 한번 epoch 가 끝나고 갱신을 진행해야 순간적으로 높은 파티클이 발생해도 오류가 생기지 않음
- if renewal == "loss" and min_loss <= Particle.g_best_score[0]:
- if min_loss < Particle.g_best_score[0]:
- self.particles[best_particle_index].update_global_best()
- else:
- if max_acc > Particle.g_best_score[1]:
- self.particles[best_particle_index].update_global_best()
- elif renewal == "acc" and max_acc >= Particle.g_best_score[1]:
- # 최고 점수 보다 높을 경우
- if max_acc > Particle.g_best_score[1]:
- # 최고 점수 갱신
- self.particles[best_particle_index].update_global_best()
- # 최고 점수 와 같을 경우
- else:
- # 최저 loss 보다 낮을 경우
- if min_loss < Particle.g_best_score[0]:
- self.particles[best_particle_index].update_global_best()
- elif renewal == "mse" and min_mse <= Particle.g_best_score[2]:
- if min_mse < Particle.g_best_score[2]:
- self.particles[best_particle_index].update_global_best()
- else:
- if max_acc > Particle.g_best_score[1]:
- self.particles[best_particle_index].update_global_best()
- # 최고 점수 갱신
- epochs_pbar.set_description(
- f"best - loss: {Particle.g_best_score[0]:.4f} - acc: {Particle.g_best_score[1]:.4f} - mse: {Particle.g_best_score[2]:.4f}"
- )
-
- if check_point is not None and epoch % check_point == 0:
- os.makedirs(
- f"./logs/{log_name}/{self.day}",
- exist_ok=True,
- )
- self._check_point_save(f"./logs/{log_name}/{self.day}/ckpt-{epoch}")
-
- tf.keras.backend.reset_uids()
- tf.keras.backend.clear_session()
- gc.collect()
-
- return Particle.g_best_score
-
- except KeyboardInterrupt:
- print("Ctrl + C : Stop Training")
-
- except MemoryError:
- print("Memory Error : Stop Training")
-
- except Exception as e:
- print(e)
-
- finally:
- self.model_save(validate_data)
- print("model save")
- if save_info:
- self.save_info()
- print("save info")
-
- def get_best_model(self):
- """
- 최고 점수를 받은 모델을 반환
-
- Returns:
- (keras.models): 모델
- """
- model = keras.models.model_from_json(self.model.to_json())
- if Particle.g_best_weights is not None:
- model.set_weights(self._decode(Particle.g_best_weights))
- model.compile(
- loss=self.loss,
- optimizer="adam",
- metrics=["accuracy", "mse"],
+ if validation_data is not None and validation_split is not None:
+ raise ValueError(
+ "validation_data and validation_split are mutually exclusive"
)
- return model
+ eval_title = self.evaluation_plugin.metadata.title
+ if fitness_size is not None and eval_title != "Fixed Subset Evaluation":
+ raise ValueError("fitness_size is only valid with evaluation='fixed_subset'")
+
+ refine_title = self.refinement_plugin.metadata.title
+ if refinement_epochs > 0 and refine_title == "No Refinement":
+ raise ValueError("refinement_epochs > 0 is valid only with refinement='adam'")
+
+ # Restore eval model parameters from constructor-time base vector and reset run state
+ self.codec.apply_vector(self._base_vector.clone(), self.eval_model)
+ self._global_best_score = None
+ self._global_best_weights = None
+ if hasattr(self, "_prev_gbest_score"):
+ del self._prev_gbest_score
+
+ val_x, val_y = None, None
+ val_source = None
+
+ if validation_data is not None:
+ if not isinstance(validation_data, tuple) or len(validation_data) != 2:
+ raise ValueError("validation_data must be a tuple of (val_x, val_y)")
+ v_x, v_y = validation_data
+ if not isinstance(v_x, torch.Tensor) or not isinstance(v_y, torch.Tensor):
+ raise TypeError(
+ "validation_data elements must be torch.Tensor instances"
+ )
+ if v_x.ndim == 0 or v_y.ndim == 0:
+ raise ValueError(
+ "validation_data elements must have a leading dimension"
+ )
+ len_val_x = v_x.shape[0]
+ len_val_y = v_y.shape[0]
+ if len_val_x != len_val_y:
+ raise ValueError(
+ f"validation_data leading dimensions must match: {len_val_x} != {len_val_y}"
+ )
+ if len_val_x == 0:
+ raise ValueError("validation_data leading dimensions must be nonzero")
+ val_x, val_y = v_x, v_y
+ val_source = "validation_data"
+
+ if validation_split is not None:
+ if (
+ isinstance(validation_split, bool)
+ or not isinstance(validation_split, (int, float))
+ or not math.isfinite(validation_split)
+ or not (0.0 < float(validation_split) < 1.0)
+ ):
+ raise ValueError(
+ "validation_split must be a finite numeric strictly between 0 and 1"
+ )
+ val_source = "validation_split"
+
+ if output_dir is not None:
+ if isinstance(output_dir, bool) or not isinstance(
+ output_dir, (str, os.PathLike)
+ ):
+ raise ValueError("output_dir must be a valid path-like string or Path")
+
+ if output_dir is None and (
+ log_format != "none" or checkpoint_interval is not None or save_info
+ ):
+ raise ValueError(
+ "output_dir is required when log_format != 'none', checkpoint_interval is set, or save_info is True"
+ )
+
+ if validation_split is not None:
+ n_samples = len_x
+ n_val = int(math.floor(n_samples * float(validation_split)))
+ if n_val == 0 or n_val >= n_samples:
+ raise ValueError(
+ "validation_split results in an empty training or validation set"
+ )
+ perm = self._random_source.permutation(n_samples)
+ val_indices = perm[:n_val]
+ train_indices = perm[n_val:]
+
+ x_train = x[train_indices]
+ val_x = x[val_indices]
+ y_train = y[train_indices]
+ val_y = y[val_indices]
else:
- return None
+ x_train = x
+ y_train = y
- def get_best_score(self):
- """
- 최고 점수를 반환
+ dtype_model = next(self.eval_model.parameters()).dtype
+ x_train_dev = x_train.to(device=self.device, dtype=dtype_model)
- Returns:
- (float): 점수
- """
- return Particle.g_best_score
+ if self.task == "multiclass":
+ if y_train.ndim > 1 and y_train.shape[-1] > 1:
+ y_train_dev = y_train.to(device=self.device, dtype=dtype_model)
+ else:
+ y_train_dev = y_train.to(device=self.device, dtype=torch.int64)
+ elif self.task in ("binary", "regression"):
+ y_train_dev = y_train.to(device=self.device, dtype=dtype_model)
- def get_best_weights(self):
- """
- 최고 점수를 받은 가중치를 반환
+ if val_x is not None and val_y is not None:
+ val_x = val_x.to(device=self.device, dtype=dtype_model)
+ if self.task == "multiclass":
+ if val_y.ndim > 1 and val_y.shape[-1] > 1:
+ val_y = val_y.to(device=self.device, dtype=dtype_model)
+ else:
+ val_y = val_y.to(device=self.device, dtype=torch.int64)
+ elif self.task in ("binary", "regression"):
+ val_y = val_y.to(device=self.device, dtype=dtype_model)
- Returns:
- (float): 가중치
- """
- return Particle.g_best_weights
+ base_vector = self.codec.encode(self.eval_model)
+ effective_fitness_size = fitness_size if fitness_size is not None else self.fitness_size
+ effective_refine_epochs = refinement_epochs if refinement_epochs > 0 else self.refinement_epochs
+ effective_refine_lr = refinement_lr if refinement_lr != 0.001 else self.refinement_lr
- def save_info(self):
- """
- 학습 정보를 저장
+ fit_ctx = FitContext(
+ optimizer=self,
+ model=self.model,
+ eval_model=self.eval_model,
+ codec=self.codec,
+ base_vector=base_vector,
+ n_particles=self.n_particles,
+ particle_min=self.particle_min,
+ particle_max=self.particle_max,
+ velocity_limit=self.velocity_limit,
+ boundary_strategy=self.boundary_strategy,
+ initial_position_noise=self.initial_position_noise,
+ seed=self.seed,
+ device=self.device,
+ rng=self._random_source,
+ task=self.task,
+ x_train=x_train_dev,
+ y_train=y_train_dev,
+ batch_size=batch_size,
+ fitness_size=effective_fitness_size,
+ renewal=renewal,
+ epochs=epochs,
+ refinement_epochs=effective_refine_epochs,
+ refinement_lr=effective_refine_lr,
+ c0=self.c0,
+ c1=self.c1,
+ w_min=self.w_min,
+ w_max=self.w_max,
+ negative_swarm=self.negative_swarm,
+ mutation_swarm=self.mutation_swarm,
+ )
- Args:
- path (str, optional): 저장 위치. Defaults to "./result".
- """
- json_save = {
- "name": f"{self.day}/{self.n_particles}_{self.c0}_{self.c1}_{self.w_min}.h5",
- "n_particles": self.n_particles,
- "score": Particle.g_best_score,
- "c0": self.c0,
- "c1": self.c1,
- "w_min": self.w_min,
- "w_max": self.w_max,
- "loss_method": self.loss,
- "empirical_balance": self.empirical_balance,
- "dispersion": self.dispersion,
- "negative_swarm": self.negative_swarm,
- "mutation_swarm": self.mutation_swarm,
- "random_state_0": self.random_state[0],
- "random_state_1": self.random_state[1].tolist(),
- "random_state_2": self.random_state[2],
- "random_state_3": self.random_state[3],
- "random_state_4": self.random_state[4],
- "renewal": self.renewal,
- }
+ # Prepare fit for all 5 stage plugins
+ self.initialization_plugin.prepare_fit(fit_ctx)
+ self.evaluation_plugin.prepare_fit(fit_ctx)
+ self.movement_plugin.prepare_fit(fit_ctx)
+ self.convergence_plugin.prepare_fit(fit_ctx)
+ self.refinement_plugin.prepare_fit(fit_ctx)
- with open(
- f"./{self.log_path}/{self.loss}_{Particle.g_best_score}.json",
- "a",
- ) as f:
- json.dump(json_save, f, indent=4)
+ # Create fresh swarm for each fit
+ num_negative = int(round(self.negative_swarm * self.n_particles))
+ self.particles = []
+ for i in range(self.n_particles):
+ p = Particle(
+ index=i,
+ base_vector=base_vector,
+ context=fit_ctx,
+ init_plugin=self.initialization_plugin,
+ negative=(i < num_negative),
+ )
+ self.particles.append(p)
- def _check_point_save(self, save_path: str = "./result/check_point"):
- """
- 중간 저장
+ x_fitness, y_fitness = self.evaluation_plugin.get_fitness_data(
+ x_train_dev, y_train_dev, fit_ctx
+ )
- Args:
- save_path (str, optional): checkpoint 저장 위치 및 이름. Defaults to f"./result/check_point".
- """
- model = self.get_best_model()
- model.save_weights(save_path)
+ best_score, history, checkpoint_snapshots = self._optimize(
+ x_fitness,
+ y_fitness,
+ fit_ctx,
+ epochs=epochs,
+ batch_size=batch_size,
+ renewal=renewal,
+ checkpoint_interval=checkpoint_interval,
+ )
- def model_save(self, valid_data: List):
- """
- 최고 점수를 받은 모델 저장
+ if effective_refine_epochs > 0:
+ refined_w, refined_s = self.refinement_plugin.refine(
+ self._global_best_weights
+ if self._global_best_weights is not None
+ else base_vector,
+ best_score,
+ self._evaluate_batch,
+ fit_ctx,
+ )
+ best_score = refined_s
- Args:
- save_path (str, optional): 모델의 저장 위치. Defaults to "./result".
+ val_score = None
+ val_sample_count = None
+ if val_x is not None and val_y is not None:
+ if self._global_best_weights is None:
+ raise RuntimeError("Best model not available after optimization")
+ raw_val = self._evaluate_aggregate_score(
+ self._global_best_weights, val_x, val_y, batch_size=batch_size
+ )
+ val_score = _validate_score(raw_val, particle_idx=-1, iteration=-1)
+ val_sample_count = val_x.shape[0]
- Returns:
- (keras.models): 모델
- """
- x, y = valid_data
- model = self.get_best_model()
-
- if model is None:
- return None
-
- score = model.evaluate(x, y, verbose=1) # type: ignore
- print(f"model score - loss: {score[0]} - acc: {score[1]} - mse: {score[2]}")
+ if output_dir is not None:
+ self._save_artifacts(
+ output_dir=output_dir,
+ epochs=epochs,
+ batch_size=batch_size,
+ fitness_size=effective_fitness_size,
+ renewal=renewal,
+ refinement_epochs=effective_refine_epochs,
+ refinement_lr=effective_refine_lr,
+ validation_split=validation_split,
+ val_source=val_source,
+ log_format=log_format,
+ checkpoint_interval=checkpoint_interval,
+ save_info=save_info,
+ best_score=best_score,
+ val_score=val_score,
+ val_sample_count=val_sample_count,
+ history=history,
+ checkpoint_snapshots=checkpoint_snapshots,
+ )
- if self.renewal == "loss":
- index = 0
- elif self.renewal == "acc":
- index = 1
- else:
- index = 2
-
- model.save(f"./{self.log_path}/model_{score[index]}.h5")
- return model
+ return best_score
diff --git a/pso/particle.py b/pso/particle.py
index 282cfaa..626c14b 100644
--- a/pso/particle.py
+++ b/pso/particle.py
@@ -1,409 +1,73 @@
-from typing import Any
-
-import numpy as np
-from tensorflow import keras
+from typing import Any, Literal
+import torch
+from .plugins import FitContext, InitializationPlugin
class Particle:
"""
- Particle Swarm Optimization의 Particle을 구현한 클래스
- 한 파티클의 life cycle은 다음과 같다.
- 1. 초기화
- 2. 손실 함수 계산
- 3. 속도 업데이트
- 4. 가중치 업데이트
- 5. 2번으로 돌아가서 반복
+ Particle Swarm Optimization particle (engine-owned state, plugin-driven movement).
+ Each particle owns position, velocity, personal best score, personal best weights,
+ and monitor state on device.
"""
- g_best_score = [np.inf, 0, np.inf]
- g_best_weights = None
- count = 0
-
- MODEL_IS_NONE = "model is None"
-
def __init__(
self,
- model: keras.Model,
- loss: Any = None,
+ index: int,
+ base_vector: torch.Tensor,
+ context: FitContext,
+ init_plugin: InitializationPlugin,
negative: bool = False,
- mutation: float = 0,
- converge_reset: bool = False,
- converge_reset_patience: int = 10,
- converge_reset_monitor: str = "loss",
- converge_reset_min_delta: float = 0.0001,
):
- """
- Args:
- model (keras.models): 학습 및 검증을 위한 모델
- loss (str|): 손실 함수
- negative (bool, optional): 음의 가중치 사용 여부 - 전역 탐색 용도(조기 수렴 방지). Defaults to False.
- mutation (float, optional): 돌연변이 확률. Defaults to 0.
- converge_reset (bool, optional): 조기 종료 사용 여부. Defaults to False.
- converge_reset_patience (int, optional): 조기 종료를 위한 기다리는 횟수. Defaults to 10.
- """
- self.set_model(model)
- self.weights = self._encode(model.get_weights())
- self.loss = loss
-
- try:
- if converge_reset and converge_reset_monitor not in [
- "acc",
- "accuracy",
- "loss",
- "mse",
- ]:
- raise ValueError(
- "converge_reset_monitor must be 'acc' or 'accuracy' or 'loss'"
- )
- if converge_reset and converge_reset_min_delta < 0:
- raise ValueError("converge_reset_min_delta must be positive")
- if converge_reset and converge_reset_patience < 0:
- raise ValueError("converge_reset_patience must be positive")
- except ValueError as e:
- print(e)
- exit(1)
-
- self.velocities = np.zeros(len(self.weights))
- self.__reset_particle()
- self.best_weights = self.weights
+ self.index = index
self.negative = negative
- self.mutation = mutation
- self.local_best_score = [np.inf, 0, np.inf]
- self.score_history = []
- self.converge_reset = converge_reset
- self.converge_reset_patience = converge_reset_patience
- self.converge_reset_monitor = converge_reset_monitor
- self.converge_reset_min_delta = converge_reset_min_delta
- Particle.count += 1
- def __del__(self):
- del self.model
- del self.loss
- del self.velocities
- del self.negative
- del self.local_best_score
- del self.best_weights
- Particle.count -= 1
+ pos, vel = init_plugin.initialize(index, base_vector, context)
+ self.position: torch.Tensor = pos
+ self.velocity: torch.Tensor = vel
- def set_shape(self, weights: list):
- """
- 가중치의 shape을 설정
+ self.personal_best_score: tuple[float, float, float] | None = None
+ self.personal_best_weights: torch.Tensor | None = None
+ self.personal_best_monitor_value: float | None = None
- Args:
- weights (list): keras model의 가중치
- """
- self.shape = [layer.shape for layer in weights]
-
- def get_shape(self):
- return self.shape
-
- def _encode(self, weights: list):
- """
- 가중치를 1차원으로 풀어서 반환
-
- Args:
- weights (list) : keras model의 가중치
- Returns:
- (numpy array) : 가중치 - 1차원으로 풀어서 반환
- (list) : 가중치의 원본 shape
- (list) : 가중치의 원본 shape의 길이
- """
- w_gpu = np.array([])
- for layer in weights:
- w_tmp = layer.reshape(-1)
- w_gpu = np.append(w_gpu, w_tmp)
-
- return w_gpu
-
- def _decode(self, weight: np.ndarray):
- """
- _encode 로 인코딩된 가중치를 원본 shape으로 복원
- 파라미터는 encode의 리턴값을 그대로 사용을 권장
-
- Args:
- weight (numpy array): 가중치 - 1차원으로 풀어서 반환
- shape (list): 가중치의 원본 shape
- length (list): 가중치의 원본 shape의 길이
- Returns:
- (list) : 가중치 원본 shape으로 복원
- """
- weights = []
- start = 0
- for i in range(len(self.shape)):
- end = start + np.prod(self.shape[i])
- w_ = weight[start:end]
- w_ = np.reshape(w_, self.shape[i])
- weights.append(w_)
- start = end
-
- del start, end, w_
- del weight
-
- return weights
-
- def get_model(self):
- if self.model is None:
- raise ValueError(self.MODEL_IS_NONE)
-
- return self.model
-
- def set_model(self, model: keras.Model):
- self.model = model
- self.set_shape(self.model.get_weights())
-
- def compile(self):
- if self.model is None:
- raise ValueError(self.MODEL_IS_NONE)
-
- self.model.compile(
- optimizer="adam",
- loss=self.loss,
- metrics=["accuracy", "mse"],
- )
-
- def get_weights(self):
- weights = self._decode(self.weights)
-
- return weights
-
- def evaluate(self, x, y):
- if self.model is None:
- raise ValueError(self.MODEL_IS_NONE)
-
- return self.model.evaluate(x, y, verbose=0) # type: ignore
-
- def get_score(self, x, y, renewal: str = "acc"):
- """
- 모델의 성능을 평가하여 점수를 반환
-
- Args:
- x (list): 입력 데이터
- y (list): 출력 데이터
- renewal (str, optional): 점수 갱신 방식. Defaults to "acc" | "acc" or "loss".
-
- Returns:
- (float): 점수
- """
-
- score = self.evaluate(x, y)
- if renewal == "loss":
- if score[0] < self.local_best_score[0]:
- self.local_best_score = score
- self.best_weights = self.weights
- elif renewal == "acc":
- if score[1] > self.local_best_score[1]:
- self.local_best_score = score
- self.best_weights = self.weights
- elif renewal == "mse":
- if score[2] < self.local_best_score[2]:
- self.local_best_score = score
- self.best_weights = self.weights
- else:
- raise ValueError("renewal must be 'acc' or 'loss' or 'mse'")
-
- return score
-
- def __check_converge_reset(
+ def reset(
self,
- score,
- monitor: str = "auto",
- patience: int = 10,
- min_delta: float = 0.0001,
- ):
+ base_vector: torch.Tensor,
+ context: FitContext,
+ init_plugin: InitializationPlugin,
+ ) -> None:
"""
- early stop을 구현한 함수
-
- Args:
- score (float): 현재 점수 [0] - loss, [1] - acc
- monitor (str, optional): 감시할 점수. Defaults to acc. | "acc" or "loss" or "mse"
- patience (int, optional): early stop을 위한 기다리는 횟수. Defaults to 10.
- min_delta (float, optional): early stop을 위한 최소 변화량. Defaults to 0.0001.
+ Resets particle position, velocity, and personal best state using the initialization plugin.
"""
- if monitor == "auto":
- monitor = "acc"
- if monitor in ["loss"]:
- self.score_history.append(score[0])
- elif monitor in ["acc", "accuracy"]:
- self.score_history.append(score[1])
- elif monitor in ["mse"]:
- self.score_history.append(score[2])
- else:
- raise ValueError("monitor must be 'acc' or 'accuracy' or 'loss' or 'mse'")
+ pos, vel = init_plugin.initialize(self.index, base_vector, context)
+ self.position = pos
+ self.velocity = vel
+ self.personal_best_score = None
+ self.personal_best_weights = None
+ self.personal_best_monitor_value = None
- if len(self.score_history) > patience:
- last_scores = self.score_history[-patience:]
- if max(last_scores) - min(last_scores) < min_delta:
- return True
- return False
-
- def __reset_particle(self):
-
- self.model = keras.models.model_from_json(self.model.to_json())
- self.model.compile(
- optimizer="adam",
- loss=self.loss,
- metrics=["accuracy", "mse"],
- )
- self.weights = self._encode(self.model.get_weights())
- rng = np.random.default_rng()
- self.velocities = rng.uniform(-0.2, 0.2, len(self.weights))
-
- self.score_history = []
-
- def _velocity_calculation(self, local_rate, global_rate, w):
+ def apply_boundary_strategy(
+ self,
+ particle_min: float | None,
+ particle_max: float | None,
+ boundary_strategy: str = "clip",
+ ) -> None:
"""
- 현재 속도 업데이트
-
- Args:
- local_rate (float): 지역 최적해의 영향력
- global_rate (float): 전역 최적해의 영향력
- w (float): 현재 속도의 영향력 - 관성 | 0.9 ~ 0.4 이 적당
+ Applies boundary constraints (clip or reflect) to particle position and velocity.
"""
- # 0회차 전역 최적해가 없을 경우 현재 파티클의 최적해로 설정 - 전역최적해의 방향을 0으로 만들기 위함
- best_particle_weights = (
- self.best_weights
- if Particle.g_best_weights is None
- else Particle.g_best_weights
- )
-
- rng = np.random.default_rng(seed=42)
- r_0 = rng.random()
- r_1 = rng.random()
-
- if self.negative:
- # 지역 최적해와 전역 최적해를 음수로 사용하여 전역 탐색을 유도
- new_v = (
- w * self.velocities
- + local_rate * r_0 * (self.best_weights - self.weights)
- - global_rate * r_1 * (best_particle_weights - self.weights)
- )
- if (
- len(self.score_history) > 10
- and max(self.score_history[-10:]) - min(self.score_history[-10:]) < 0.01
- ):
- self.__reset_particle()
-
- else:
- # 전역 최적해의 acc 가 높을수록 더 빠르게 수렴
- # 하지만 loss 가 커진 상태에서는 전역 최적해의 영향이
- new_v = (
- w * self.velocities
- + local_rate
- * self.local_best_score[1]
- * r_0
- * (self.best_weights - self.weights)
- + global_rate
- # * Particle.g_best_score[1]
- * r_1 * (best_particle_weights - self.weights)
- )
-
- if self.mutation != 0.0 and rng.random() < self.mutation:
- m_v = rng.uniform(-0.2, 0.2, len(self.velocities))
- new_v = m_v
-
- self.velocities = new_v
-
- del r_0, r_1
-
- def _position_update(self):
- """
- 가중치 업데이트
- """
- self.weights = np.add(self.weights, self.velocities)
-
- self.model.set_weights(self.get_weights())
-
- def step(self, x, y, local_rate, global_rate, w, renewal: str = "acc"):
- """
- 파티클의 한 스텝을 진행합니다.
-
- Args:
- x (list): 입력 데이터
- y (list): 출력 데이터
- local_rate (float): 지역최적해의 영향력
- global_rate (float): 전역최적해의 영향력
- w (float): 관성
- g_best (list): 전역최적해
- renewal (str, optional): 최고점수 갱신 방식. Defaults to "acc" | "acc" or "loss"
-
- Returns:
- list: 현재 파티클의 점수
- """
- self._velocity_calculation(local_rate, global_rate, w)
- self._position_update()
-
- score = self.get_score(x, y, renewal)
-
- if self.converge_reset and self.__check_converge_reset(
- score,
- self.converge_reset_monitor,
- self.converge_reset_patience,
- self.converge_reset_min_delta,
- ):
- self.__reset_particle()
- score = self.get_score(x, y, renewal)
-
- while (
- np.isnan(score[0])
- or np.isnan(score[1])
- or np.isnan(score[2])
- or score[0] == 0
- or score[1] == 0
- or score[2] == 0
- or np.isinf(score[0])
- or np.isinf(score[1])
- or np.isinf(score[2])
- or score[0] > 1000
- or score[1] > 1
- or score[2] > 1000
- ):
- self.__reset_particle()
- score = self.get_score(x, y, renewal)
-
- return score
-
- def get_best_score(self):
- """
- 파티클의 최고점수를 반환합니다.
-
- Returns:
- float: 최고점수
- """
- return self.local_best_score
-
- def get_best_weights(self):
- """
- 파티클의 최고점수를 받은 가중치를 반환합니다
-
- Returns:
- list: 가중치 리스트
- """
- return self._decode(self.best_weights)
-
- def set_global_score(self):
- """전역 최고점수를 현재 파티클의 최고점수로 설정합니다"""
- Particle.g_best_score = self.local_best_score
-
- def set_global_weights(self):
- """전역 최고점수를 받은 가중치를 현재 파티클의 최고점수를 받은 가중치로 설정합니다"""
- Particle.g_best_weights = self.best_weights
-
- def update_global_best(self):
- """현재 파티클의 점수와 가중치를 전역 최고점수와 가중치로 설정합니다"""
- self.set_global_score()
- self.set_global_weights()
-
- def check_global_best(self, renewal: str = "loss"):
- if (
- (renewal == "loss" and self.local_best_score[0] < Particle.g_best_score[0])
- or (
- renewal == "acc" and self.local_best_score[1] > Particle.g_best_score[1]
- )
- or (
- renewal == "mse" and self.local_best_score[2] < Particle.g_best_score[2]
- )
- ):
- self.update_global_best()
-
-
-# 끝
+ if particle_min is not None and particle_max is not None:
+ if boundary_strategy == "reflect":
+ span = float(particle_max - particle_min)
+ shift = self.position - particle_min
+ q = torch.floor(shift / span).to(torch.int64)
+ m = torch.remainder(shift, 2.0 * span)
+ bounded_pos = torch.where(
+ m <= span,
+ particle_min + m,
+ particle_min + (2.0 * span - m),
+ )
+ self.velocity = torch.where(q % 2 != 0, -self.velocity, self.velocity)
+ self.position = bounded_pos
+ else:
+ self.position = torch.clamp(
+ self.position, particle_min, particle_max
+ )
diff --git a/pso/plugins.py b/pso/plugins.py
new file mode 100644
index 0000000..9e282d1
--- /dev/null
+++ b/pso/plugins.py
@@ -0,0 +1,1566 @@
+import copy
+from dataclasses import dataclass
+import inspect
+import math
+from typing import Any, Literal, Sequence
+import torch
+import torch.nn as nn
+
+
+@dataclass(frozen=True)
+class PluginMetadata:
+ stage: Literal["movement", "initialization", "evaluation", "convergence", "refinement"]
+ title: str
+ source: str | None = None
+ gradient_required: bool = False
+ fidelity: Literal["canonical", "experimental"] = "canonical"
+
+
+@dataclass(frozen=True)
+class SwarmState:
+ positions: tuple[torch.Tensor, ...]
+ velocities: tuple[torch.Tensor, ...]
+ pbest_positions: tuple[torch.Tensor, ...]
+ pbest_scores: tuple[tuple[float, float, float], ...]
+ gbest_position: torch.Tensor
+ gbest_score: tuple[float, float, float]
+ pbest_improved: tuple[bool, ...]
+
+
+@dataclass
+class FitContext:
+ optimizer: Any
+ model: nn.Module
+ eval_model: nn.Module
+ codec: Any
+ base_vector: torch.Tensor
+ n_particles: int
+ particle_min: float | None
+ particle_max: float | None
+ velocity_limit: float | None
+ boundary_strategy: str
+ initial_position_noise: float
+ seed: int | None
+ device: torch.device
+ rng: Any
+ task: str
+ x_train: torch.Tensor
+ y_train: torch.Tensor
+ batch_size: int | None
+ fitness_size: int | None
+ renewal: str
+ epochs: int
+ refinement_epochs: int
+ refinement_lr: float
+ c0: float | None = None
+ c1: float | None = None
+ w_min: float | None = None
+ w_max: float | None = None
+ negative_swarm: float = 0.0
+ mutation_swarm: float = 0.0
+
+
+@dataclass
+class IterationContext:
+ epoch: int
+ total_epochs: int
+ w: float
+ particle_idx: int
+ is_negative: bool
+ rng: Any
+ optimizer: Any
+
+
+def _is_better_score(
+ score_a: Sequence[float],
+ score_b: Sequence[float] | None,
+ renewal: str = "acc",
+) -> bool:
+ if score_b is None:
+ return True
+ if renewal == "acc":
+ if score_a[1] != score_b[1]:
+ return score_a[1] > score_b[1]
+ if score_a[0] != score_b[0]:
+ return score_a[0] < score_b[0]
+ return score_a[2] < score_b[2]
+ elif renewal == "loss":
+ if score_a[0] != score_b[0]:
+ return score_a[0] < score_b[0]
+ if score_a[1] != score_b[1]:
+ return score_a[1] > score_b[1]
+ return score_a[2] < score_b[2]
+ elif renewal == "mse":
+ if score_a[2] != score_b[2]:
+ return score_a[2] < score_b[2]
+ if score_a[0] != score_b[0]:
+ return score_a[0] < score_b[0]
+ return score_a[1] > score_b[1]
+ return False
+
+
+def _is_at_least_delta(delta: float, min_delta: float) -> bool:
+ if min_delta > 0:
+ return delta >= min_delta
+ return delta > 0
+
+
+class BasePlugin:
+ metadata: PluginMetadata
+
+ def prepare_fit(self, context: FitContext) -> None:
+ pass
+
+ def get_options(self) -> dict[str, Any]:
+ return {}
+class InitializationPlugin(BasePlugin):
+ def initialize(
+ self, index: int, base_vector: torch.Tensor, context: FitContext
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ raise NotImplementedError
+
+
+class ModelNoiseInitialization(InitializationPlugin):
+ metadata = PluginMetadata(
+ stage="initialization",
+ title="Model Weight + Uniform Noise Initialization",
+ source=None,
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def __init__(self, noise: float = 0.05):
+ if (
+ isinstance(noise, bool)
+ or not isinstance(noise, (int, float))
+ or not math.isfinite(noise)
+ or float(noise) < 0.0
+ ):
+ raise ValueError("noise must be a finite nonnegative number")
+ self.noise = float(noise)
+
+ def get_options(self) -> dict[str, Any]:
+ return {"noise": self.noise}
+
+ def initialize(
+ self, index: int, base_vector: torch.Tensor, context: FitContext
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ device = base_vector.device
+ dtype = base_vector.dtype
+ noise_val = (
+ context.initial_position_noise
+ if context.initial_position_noise is not None
+ else self.noise
+ )
+ pos = base_vector.clone()
+ if noise_val > 0.0:
+ n = context.rng.uniform(
+ pos.shape, -noise_val, noise_val, device=device, dtype=dtype
+ )
+ pos = pos + n
+ if context.particle_min is not None and context.particle_max is not None:
+ pos = torch.clamp(pos, context.particle_min, context.particle_max)
+ vel = context.rng.uniform(pos.shape, -0.2, 0.2, device=device, dtype=dtype)
+ if context.velocity_limit is not None:
+ vel = torch.clamp(vel, -context.velocity_limit, context.velocity_limit)
+ return pos, vel
+
+
+class UniformInitialization(InitializationPlugin):
+ metadata = PluginMetadata(
+ stage="initialization",
+ title="Uniform Bounded Space Initialization",
+ source=None,
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def initialize(
+ self, index: int, base_vector: torch.Tensor, context: FitContext
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ if context.particle_min is None or context.particle_max is None:
+ raise ValueError(
+ "uniform initialization requires finite particle_min and particle_max bounds"
+ )
+ device = base_vector.device
+ dtype = base_vector.dtype
+ pos = context.rng.uniform(
+ base_vector.shape,
+ context.particle_min,
+ context.particle_max,
+ device=device,
+ dtype=dtype,
+ )
+ vel = context.rng.uniform(pos.shape, -0.2, 0.2, device=device, dtype=dtype)
+ if context.velocity_limit is not None:
+ vel = torch.clamp(vel, -context.velocity_limit, context.velocity_limit)
+ return pos, vel
+
+
+class EvaluationPlugin(BasePlugin):
+ def get_fitness_data(
+ self, x_train: torch.Tensor, y_train: torch.Tensor, context: FitContext
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ raise NotImplementedError
+
+
+class FullEvaluation(EvaluationPlugin):
+ metadata = PluginMetadata(
+ stage="evaluation",
+ title="Full Dataset Evaluation",
+ source=None,
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def get_fitness_data(
+ self, x_train: torch.Tensor, y_train: torch.Tensor, context: FitContext
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ return x_train, y_train
+
+
+class FixedSubsetEvaluation(EvaluationPlugin):
+ metadata = PluginMetadata(
+ stage="evaluation",
+ title="Fixed Subset Evaluation",
+ source=None,
+ gradient_required=False,
+ fidelity="experimental",
+ )
+
+ def __init__(self, fitness_size: int | None = None):
+ if fitness_size is not None:
+ if (
+ isinstance(fitness_size, bool)
+ or not isinstance(fitness_size, int)
+ or fitness_size < 1
+ ):
+ raise ValueError("fitness_size must be an integer >= 1")
+ self.fitness_size = fitness_size
+ self._x_sub: torch.Tensor | None = None
+ self._y_sub: torch.Tensor | None = None
+
+ def get_options(self) -> dict[str, Any]:
+ return {"fitness_size": self.fitness_size}
+
+ def prepare_fit(self, context: FitContext) -> None:
+ f_size = (
+ context.fitness_size
+ if context.fitness_size is not None
+ else self.fitness_size
+ )
+ if f_size is None or f_size <= 0:
+ raise ValueError(
+ "evaluation='fixed_subset' requires a positive fitness_size"
+ )
+ n_train = context.x_train.shape[0]
+ if f_size > n_train:
+ raise ValueError(
+ f"fitness_size ({f_size}) cannot exceed post-validation-split training size ({n_train})"
+ )
+ fitness_idx = context.rng.choice(n_train, size=f_size)
+ self._x_sub = context.x_train[fitness_idx]
+ self._y_sub = context.y_train[fitness_idx]
+
+ def get_fitness_data(
+ self, x_train: torch.Tensor, y_train: torch.Tensor, context: FitContext
+ ) -> tuple[torch.Tensor, torch.Tensor]:
+ if self._x_sub is None or self._y_sub is None:
+ raise RuntimeError(
+ "FixedSubsetEvaluation was not prepared before get_fitness_data"
+ )
+ return self._x_sub, self._y_sub
+
+
+class MovementPlugin(BasePlugin):
+ def propose(
+ self, particle_idx: int, state: SwarmState, context: IterationContext
+ ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+ raise NotImplementedError
+
+ def on_epoch_end(self, state: SwarmState, context: IterationContext) -> None:
+ pass
+
+ def reset_particle_state(self, particle_idx: int) -> None:
+ pass
+
+
+class OriginalMovement(MovementPlugin):
+ metadata = PluginMetadata(
+ stage="movement",
+ title="Original PSO",
+ source="10.1109/ICNN.1995.488968",
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def __init__(self, c0: float = 2.0, c1: float = 2.0):
+ for name, val in [("c0", c0), ("c1", c1)]:
+ if (
+ isinstance(val, bool)
+ or not isinstance(val, (int, float))
+ or not math.isfinite(val)
+ ):
+ raise ValueError(f"{name} must be a finite number")
+ self.c0 = float(c0)
+ self.c1 = float(c1)
+
+ def get_options(self) -> dict[str, Any]:
+ return {"c0": self.c0, "c1": self.c1}
+
+ def propose(
+ self, particle_idx: int, state: SwarmState, context: IterationContext
+ ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+ x = state.positions[particle_idx]
+ v = state.velocities[particle_idx]
+ pbest = state.pbest_positions[particle_idx]
+ gbest = state.gbest_position
+ device = x.device
+ dtype = x.dtype
+
+ r1 = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+ r2 = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+
+ cog = self.c0 * r1 * (pbest - x)
+ if not context.is_negative:
+ soc = self.c1 * r2 * (gbest - x)
+ else:
+ soc = -self.c1 * r2 * (gbest - x)
+
+ v_new = v + cog + soc
+ return None, v_new
+
+
+class InertiaMovement(MovementPlugin):
+ metadata = PluginMetadata(
+ stage="movement",
+ title="Inertia Weight PSO",
+ source="10.1109/ICEC.1998.699146",
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def __init__(
+ self,
+ c0: float = 2.0,
+ c1: float = 2.0,
+ w_min: float = 0.4,
+ w_max: float = 0.9,
+ ):
+ for name, val in [
+ ("c0", c0),
+ ("c1", c1),
+ ("w_min", w_min),
+ ("w_max", w_max),
+ ]:
+ if (
+ isinstance(val, bool)
+ or not isinstance(val, (int, float))
+ or not math.isfinite(val)
+ ):
+ raise ValueError(f"{name} must be a finite number")
+ if float(w_min) > float(w_max):
+ raise ValueError("w_min must be <= w_max")
+ self.c0 = float(c0)
+ self.c1 = float(c1)
+ self.w_min = float(w_min)
+ self.w_max = float(w_max)
+
+ def get_options(self) -> dict[str, Any]:
+ return {"c0": self.c0, "c1": self.c1, "w_min": self.w_min, "w_max": self.w_max}
+
+ def propose(
+ self, particle_idx: int, state: SwarmState, context: IterationContext
+ ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+ x = state.positions[particle_idx]
+ v = state.velocities[particle_idx]
+ pbest = state.pbest_positions[particle_idx]
+ gbest = state.gbest_position
+ device = x.device
+ dtype = x.dtype
+
+ r1 = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+ r2 = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+
+ cog = self.c0 * r1 * (pbest - x)
+ if not context.is_negative:
+ soc = self.c1 * r2 * (gbest - x)
+ else:
+ soc = -self.c1 * r2 * (gbest - x)
+
+ v_new = context.w * v + cog + soc
+ return None, v_new
+
+
+class ConstrictionMovement(MovementPlugin):
+ metadata = PluginMetadata(
+ stage="movement",
+ title="Constriction Coefficient PSO",
+ source="10.1109/4235.985692",
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def __init__(self, c0: float = 2.05, c1: float = 2.05):
+ for name, val in [("c0", c0), ("c1", c1)]:
+ if (
+ isinstance(val, bool)
+ or not isinstance(val, (int, float))
+ or not math.isfinite(val)
+ ):
+ raise ValueError(f"{name} must be a finite number")
+ self.c0 = float(c0)
+ self.c1 = float(c1)
+ phi = self.c0 + self.c1
+ if phi <= 4.0:
+ raise ValueError(f"Constriction PSO requires c0 + c1 > 4.0, got phi={phi}")
+ self.chi = 2.0 / abs(2.0 - phi - math.sqrt(phi * phi - 4.0 * phi))
+
+ def get_options(self) -> dict[str, Any]:
+ return {"c0": self.c0, "c1": self.c1, "chi": float(self.chi)}
+
+ def propose(
+ self, particle_idx: int, state: SwarmState, context: IterationContext
+ ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+ x = state.positions[particle_idx]
+ v = state.velocities[particle_idx]
+ pbest = state.pbest_positions[particle_idx]
+ gbest = state.gbest_position
+ device = x.device
+ dtype = x.dtype
+
+ r1 = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+ r2 = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+
+ cog = self.c0 * r1 * (pbest - x)
+ if not context.is_negative:
+ soc = self.c1 * r2 * (gbest - x)
+ else:
+ soc = -self.c1 * r2 * (gbest - x)
+
+ v_new = self.chi * (v + cog + soc)
+ return None, v_new
+
+
+class FIPSMovement(MovementPlugin):
+ metadata = PluginMetadata(
+ stage="movement",
+ title="Fully Informed Particle Swarm (FIPS)",
+ source="10.1109/TEVC.2004.826074",
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def __init__(self, c0: float = 2.05, c1: float = 2.05):
+ for name, val in [("c0", c0), ("c1", c1)]:
+ if (
+ isinstance(val, bool)
+ or not isinstance(val, (int, float))
+ or not math.isfinite(val)
+ ):
+ raise ValueError(f"{name} must be a finite number")
+ self.c0 = float(c0)
+ self.c1 = float(c1)
+ phi = self.c0 + self.c1
+ if phi <= 4.0:
+ raise ValueError(f"FIPS requires c0 + c1 > 4.0, got phi={phi}")
+ self.phi = phi
+ self.chi = 2.0 / abs(2.0 - phi - math.sqrt(phi * phi - 4.0 * phi))
+
+ def get_options(self) -> dict[str, Any]:
+ return {"c0": self.c0, "c1": self.c1, "phi": float(self.phi), "chi": float(self.chi)}
+
+ def prepare_fit(self, context: FitContext) -> None:
+ if context.negative_swarm != 0.0:
+ raise ValueError("negative_swarm is unsupported for FIPS")
+
+ def propose(
+ self, particle_idx: int, state: SwarmState, context: IterationContext
+ ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+ if context.is_negative:
+ raise ValueError("negative_swarm is unsupported for FIPS")
+ x = state.positions[particle_idx]
+ v = state.velocities[particle_idx]
+ device = x.device
+ dtype = x.dtype
+ n_particles = len(state.positions)
+
+ scale = self.phi / float(n_particles)
+ social_term = torch.zeros_like(x)
+ for j in range(n_particles):
+ pbest_j = state.pbest_positions[j]
+ r_j = context.rng.uniform(x.shape, 0.0, scale, device=device, dtype=dtype)
+ social_term = social_term + r_j * (pbest_j - x)
+
+ v_new = self.chi * (v + social_term)
+ return None, v_new
+
+
+class CLPSOMovement(MovementPlugin):
+ metadata = PluginMetadata(
+ stage="movement",
+ title="Comprehensive Learning PSO (CLPSO)",
+ source="10.1109/TEVC.2005.857610",
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def __init__(
+ self,
+ c: float = 1.49445,
+ w_min: float = 0.4,
+ w_max: float = 0.9,
+ refresh_gap: int = 7,
+ c0: float | None = None,
+ ):
+ c_val = float(c0) if c0 is not None else float(c)
+ if not math.isfinite(c_val) or c_val <= 0.0:
+ raise ValueError("CLPSO acceleration coefficient must be positive")
+ if (
+ isinstance(w_min, bool)
+ or not isinstance(w_min, (int, float))
+ or not math.isfinite(w_min)
+ or isinstance(w_max, bool)
+ or not isinstance(w_max, (int, float))
+ or not math.isfinite(w_max)
+ ):
+ raise ValueError("w_min and w_max must be finite numbers")
+ if float(w_min) > float(w_max):
+ raise ValueError("w_min must be <= w_max")
+ if (
+ isinstance(refresh_gap, bool)
+ or not isinstance(refresh_gap, int)
+ or refresh_gap < 1
+ ):
+ raise ValueError("refresh_gap must be an integer >= 1")
+
+ self.c = c_val
+ self.c0 = c_val
+ self.w_min = float(w_min)
+ self.w_max = float(w_max)
+ self.refresh_gap = int(refresh_gap)
+ self.exemplars: torch.Tensor | None = None
+ self.stagnation: torch.Tensor | None = None
+ self.learning_probs: torch.Tensor | None = None
+ self._pbest_matrix: torch.Tensor | None = None
+ self._dim_indices: torch.Tensor | None = None
+ self._ranks: torch.Tensor | None = None
+ self.n_particles: int = 0
+ self.dim: int = 0
+ self.renewal: str = "acc"
+
+ def get_options(self) -> dict[str, Any]:
+ return {
+ "c": self.c,
+ "c0": self.c,
+ "w_min": self.w_min,
+ "w_max": self.w_max,
+ "refresh_gap": self.refresh_gap,
+ }
+
+ def prepare_fit(self, context: FitContext) -> None:
+ if context.negative_swarm != 0.0:
+ raise ValueError("negative_swarm is unsupported for CLPSO")
+ self.n_particles = context.n_particles
+ self.dim = context.base_vector.numel()
+ self.renewal = context.renewal
+
+ probs = torch.zeros((self.n_particles,), dtype=torch.float32)
+ if self.n_particles == 1:
+ probs[0] = 0.05
+ else:
+ denom = math.exp(10.0) - 1.0
+ for i in range(self.n_particles):
+ probs[i] = (
+ 0.05
+ + 0.45
+ * (math.exp(10.0 * i / (self.n_particles - 1)) - 1.0)
+ / denom
+ )
+
+ self.learning_probs = probs
+ self.stagnation = torch.zeros((self.n_particles,), dtype=torch.int64)
+ self.exemplars = None
+ self._pbest_matrix = None
+ self._dim_indices = None
+ self._ranks = None
+
+ def _sample_exemplars_for_particle(
+ self,
+ particle_idx: int,
+ state: SwarmState,
+ rng: Any,
+ ) -> None:
+ assert self.exemplars is not None
+ assert self.learning_probs is not None
+ assert self._ranks is not None
+
+ pc = float(self.learning_probs[particle_idx])
+ n_particles = self.n_particles
+ dim = self.dim
+
+ ex = torch.full((dim,), particle_idx, dtype=torch.int64)
+
+ if n_particles == 1:
+ self.exemplars[particle_idx] = ex
+ return
+
+ candidates = [p for p in range(n_particles) if p != particle_idx]
+ k = len(candidates)
+ candidates_t = torch.tensor(candidates, dtype=torch.int64)
+
+ if k == 1:
+ r = rng.uniform((dim,), 0.0, 1.0, device="cpu")
+ mask = (r < pc)
+ if mask.any():
+ ex[mask] = candidates_t[0]
+ else:
+ d_pick = int(rng.randint(0, dim, size=1, device="cpu").item())
+ ex[d_pick] = candidates_t[0]
+ self.exemplars[particle_idx] = ex
+ return
+
+ r = rng.uniform((dim,), 0.0, 1.0, device="cpu")
+ mask = (r < pc)
+ m = int(mask.sum().item())
+
+ if m > 0:
+ c_idx1 = rng.randint(0, k, size=m, device="cpu")
+ c_idx2_raw = rng.randint(0, k - 1, size=m, device="cpu")
+ c_idx2 = torch.where(c_idx2_raw >= c_idx1, c_idx2_raw + 1, c_idx2_raw)
+
+ p1 = candidates_t[c_idx1]
+ p2 = candidates_t[c_idx2]
+
+ rank1 = self._ranks[p1]
+ rank2 = self._ranks[p2]
+
+ winners = torch.where(rank1 < rank2, p1, p2)
+ ex[mask] = winners
+ all_own = False
+ else:
+ all_own = True
+
+ if all_own:
+ d_pick = int(rng.randint(0, dim, size=1, device="cpu").item())
+ c_idx1 = int(rng.randint(0, k, size=1, device="cpu").item())
+ c_idx2_raw = int(rng.randint(0, k - 1, size=1, device="cpu").item())
+ c_idx2 = c_idx2_raw + 1 if c_idx2_raw >= c_idx1 else c_idx2_raw
+
+ p1 = candidates_t[c_idx1].item()
+ p2 = candidates_t[c_idx2].item()
+
+ winner = p1 if self._ranks[p1] < self._ranks[p2] else p2
+ ex[d_pick] = winner
+
+ self.exemplars[particle_idx] = ex
+
+ def propose(
+ self, particle_idx: int, state: SwarmState, context: IterationContext
+ ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+ if context.is_negative:
+ raise ValueError("negative_swarm is unsupported for CLPSO")
+ if self.exemplars is None or self._pbest_matrix is None or self._ranks is None:
+ self.on_epoch_end(state, context)
+
+ assert self.exemplars is not None
+ assert self._pbest_matrix is not None
+ x = state.positions[particle_idx]
+ v = state.velocities[particle_idx]
+ device = x.device
+ dtype = x.dtype
+ dim = x.numel()
+
+ pbest_device = self._pbest_matrix.device
+ if (
+ self._dim_indices is None
+ or self._dim_indices.device != pbest_device
+ or self._dim_indices.numel() != dim
+ ):
+ self._dim_indices = torch.arange(dim, device=pbest_device)
+
+ ex_indices = self.exemplars[particle_idx].to(device=pbest_device)
+ e_i = self._pbest_matrix[ex_indices, self._dim_indices].to(
+ device=device, dtype=dtype
+ )
+
+ r = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+ v_new = context.w * v + self.c * r * (e_i - x)
+ return None, v_new
+
+ def on_epoch_end(self, state: SwarmState, context: IterationContext) -> None:
+ if self.n_particles == 0:
+ return
+
+ self._pbest_matrix = torch.stack(state.pbest_positions)
+
+ scores_keys = []
+ for score in state.pbest_scores:
+ if score is None:
+ scores_keys.append((float("inf"), float("inf"), float("inf")))
+ else:
+ loss, acc, mse = score
+ if self.renewal in ("acc", "accuracy"):
+ scores_keys.append((-acc, loss, mse))
+ elif self.renewal == "loss":
+ scores_keys.append((loss, -acc, mse))
+ else:
+ scores_keys.append((mse, loss, -acc))
+ sorted_indices = sorted(range(self.n_particles), key=lambda idx: scores_keys[idx])
+ ranks = torch.zeros(self.n_particles, dtype=torch.int64)
+ for rank, idx in enumerate(sorted_indices):
+ ranks[idx] = rank
+ self._ranks = ranks
+
+ if self.exemplars is None:
+ self.exemplars = torch.zeros((self.n_particles, self.dim), dtype=torch.int64)
+ for i in range(self.n_particles):
+ self._sample_exemplars_for_particle(i, state, context.rng)
+ if self.stagnation is not None:
+ self.stagnation.zero_()
+ return
+
+ if self.stagnation is None:
+ return
+ n_particles = len(state.positions)
+ for i in range(n_particles):
+ if state.pbest_improved[i]:
+ self.stagnation[i] = 0
+ else:
+ self.stagnation[i] += 1
+ if self.stagnation[i] >= self.refresh_gap:
+ self._sample_exemplars_for_particle(i, state, context.rng)
+ self.stagnation[i] = 0
+
+ def reset_particle_state(self, particle_idx: int) -> None:
+ if self.stagnation is not None and particle_idx < len(self.stagnation):
+ self.stagnation[particle_idx] = 0
+class BareBonesMovement(MovementPlugin):
+ metadata = PluginMetadata(
+ stage="movement",
+ title="Bare Bones PSO",
+ source="10.1109/SIS.2003.1202251",
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def prepare_fit(self, context: FitContext) -> None:
+ if context.negative_swarm != 0.0:
+ raise ValueError("negative_swarm is unsupported for Bare Bones PSO")
+ if context.mutation_swarm != 0.0:
+ raise ValueError("mutation_swarm is unsupported for Bare Bones PSO")
+ if context.velocity_limit is not None:
+ raise ValueError("velocity_limit is unsupported for Bare Bones PSO")
+
+ def propose(
+ self, particle_idx: int, state: SwarmState, context: IterationContext
+ ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+ if context.is_negative:
+ raise ValueError("negative_swarm is unsupported for Bare Bones PSO")
+ x = state.positions[particle_idx]
+ pbest = state.pbest_positions[particle_idx]
+ gbest = state.gbest_position
+ device = x.device
+ dtype = x.dtype
+
+ mu = 0.5 * (pbest + gbest)
+ sigma = torch.abs(pbest - gbest)
+
+ r_norm = torch.randn(
+ x.shape,
+ generator=context.rng.cpu_generator,
+ device="cpu",
+ dtype=dtype,
+ ).to(device)
+ gauss_sample = mu + sigma * r_norm
+
+ u = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+ x_new = torch.where(u < 0.5, pbest, gauss_sample)
+ v_new = torch.zeros_like(x)
+ return x_new, v_new
+
+
+class AdaptiveMomentMovement(MovementPlugin):
+ metadata = PluginMetadata(
+ stage="movement",
+ title="Adaptive Path-Moment PSO",
+ source=None,
+ gradient_required=False,
+ fidelity="experimental",
+ )
+
+ def __init__(
+ self,
+ c0: float = 0.5,
+ c1: float = 0.3,
+ w_min: float = 0.1,
+ w_max: float = 0.9,
+ moment_blend: float = 0.25,
+ moment_beta1: float = 0.9,
+ moment_beta2: float = 0.999,
+ moment_step_size: float = 1.0,
+ moment_epsilon: float = 1e-8,
+ ):
+ for name, val in [
+ ("c0", c0),
+ ("c1", c1),
+ ("w_min", w_min),
+ ("w_max", w_max),
+ ]:
+ if (
+ isinstance(val, bool)
+ or not isinstance(val, (int, float))
+ or not math.isfinite(val)
+ ):
+ raise ValueError(f"{name} must be a finite number")
+ if float(w_min) > float(w_max):
+ raise ValueError("w_min must be <= w_max")
+
+ if (
+ isinstance(moment_blend, bool)
+ or not isinstance(moment_blend, (int, float))
+ or not math.isfinite(moment_blend)
+ or not (0.0 <= float(moment_blend) <= 1.0)
+ ):
+ raise ValueError("moment_blend must be a finite float in range [0, 1]")
+
+ for name, val in [
+ ("moment_beta1", moment_beta1),
+ ("moment_beta2", moment_beta2),
+ ]:
+ if (
+ isinstance(val, bool)
+ or not isinstance(val, (int, float))
+ or not math.isfinite(val)
+ or not (0.0 < float(val) < 1.0)
+ ):
+ raise ValueError(f"{name} must be a finite float strictly in range (0, 1)")
+
+ if (
+ isinstance(moment_step_size, bool)
+ or not isinstance(moment_step_size, (int, float))
+ or not math.isfinite(moment_step_size)
+ or float(moment_step_size) <= 0.0
+ ):
+ raise ValueError("moment_step_size must be a positive finite float")
+
+ if (
+ isinstance(moment_epsilon, bool)
+ or not isinstance(moment_epsilon, (int, float))
+ or not math.isfinite(moment_epsilon)
+ or float(moment_epsilon) <= 0.0
+ ):
+ raise ValueError("moment_epsilon must be a positive finite float")
+
+ self.c0 = float(c0)
+ self.c1 = float(c1)
+ self.w_min = float(w_min)
+ self.w_max = float(w_max)
+ self.moment_blend = float(moment_blend)
+ self.moment_beta1 = float(moment_beta1)
+ self.moment_beta2 = float(moment_beta2)
+ self.moment_step_size = float(moment_step_size)
+ self.moment_epsilon = float(moment_epsilon)
+
+ self.first_moments: list[torch.Tensor | None] = []
+ self.second_moments: list[torch.Tensor | None] = []
+ self.moment_steps: list[int] = []
+
+ def get_options(self) -> dict[str, Any]:
+ return {
+ "c0": self.c0,
+ "c1": self.c1,
+ "w_min": self.w_min,
+ "w_max": self.w_max,
+ "moment_blend": self.moment_blend,
+ "moment_beta1": self.moment_beta1,
+ "moment_beta2": self.moment_beta2,
+ "moment_step_size": self.moment_step_size,
+ "moment_epsilon": self.moment_epsilon,
+ }
+
+ def prepare_fit(self, context: FitContext) -> None:
+ dim = context.base_vector.numel()
+ device = context.device
+ dtype = context.base_vector.dtype
+ n_particles = context.n_particles
+
+ self.first_moments = []
+ self.second_moments = []
+ self.moment_steps = [0] * n_particles
+
+ if self.moment_blend > 0.0:
+ for _ in range(n_particles):
+ self.first_moments.append(
+ torch.zeros(dim, device=device, dtype=dtype)
+ )
+ self.second_moments.append(
+ torch.zeros(dim, device=device, dtype=dtype)
+ )
+ else:
+ for _ in range(n_particles):
+ self.first_moments.append(None)
+ self.second_moments.append(None)
+
+ def reset_particle_state(self, particle_idx: int) -> None:
+ if (
+ particle_idx < len(self.first_moments)
+ and self.first_moments[particle_idx] is not None
+ ):
+ self.first_moments[particle_idx].zero_()
+ if (
+ particle_idx < len(self.second_moments)
+ and self.second_moments[particle_idx] is not None
+ ):
+ self.second_moments[particle_idx].zero_()
+ if particle_idx < len(self.moment_steps):
+ self.moment_steps[particle_idx] = 0
+
+ def propose(
+ self, particle_idx: int, state: SwarmState, context: IterationContext
+ ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+ x = state.positions[particle_idx]
+ v = state.velocities[particle_idx]
+ pbest = state.pbest_positions[particle_idx]
+ gbest = state.gbest_position
+ device = x.device
+ dtype = x.dtype
+
+ r1 = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+ r2 = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+
+ cog = self.c0 * r1 * (pbest - x)
+ if not context.is_negative:
+ soc = self.c1 * r2 * (gbest - x)
+ else:
+ soc = -self.c1 * r2 * (gbest - x)
+
+ standard_velocity = context.w * v + cog + soc
+
+ if self.moment_blend > 0.0:
+ fm = self.first_moments[particle_idx]
+ sm = self.second_moments[particle_idx]
+ if fm is None or sm is None:
+ fm = torch.zeros_like(x)
+ sm = torch.zeros_like(x)
+ self.first_moments[particle_idx] = fm
+ self.second_moments[particle_idx] = sm
+
+ self.moment_steps[particle_idx] += 1
+ step = self.moment_steps[particle_idx]
+
+ fm.mul_(self.moment_beta1).add_(
+ standard_velocity, alpha=1.0 - self.moment_beta1
+ )
+ sm.mul_(self.moment_beta2).addcmul_(
+ standard_velocity,
+ standard_velocity,
+ value=1.0 - self.moment_beta2,
+ )
+
+ bias_corr1 = 1.0 - (self.moment_beta1**step)
+ bias_corr2 = 1.0 - (self.moment_beta2**step)
+
+ first_hat = fm / bias_corr1
+ second_hat = sm / bias_corr2
+
+ historical_scale = torch.sqrt(torch.mean(second_hat))
+ adaptive_direction = (
+ self.moment_step_size
+ * historical_scale
+ * first_hat
+ / (torch.sqrt(second_hat) + self.moment_epsilon)
+ )
+
+ v_new = (
+ (1.0 - self.moment_blend) * standard_velocity
+ + self.moment_blend * adaptive_direction
+ )
+ else:
+ v_new = standard_velocity
+
+ return None, v_new
+
+
+
+class RingLocalBestMovement(MovementPlugin):
+ metadata = PluginMetadata(
+ stage="movement",
+ title="Ring Local Best PSO",
+ source="10.1109/CEC.2002.1004493",
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def __init__(
+ self,
+ c0: float = 1.49618,
+ c1: float = 1.49618,
+ w_min: float = 0.4,
+ w_max: float = 0.9,
+ neighborhood_radius: int = 1,
+ ):
+ for name, val in [
+ ("c0", c0),
+ ("c1", c1),
+ ("w_min", w_min),
+ ("w_max", w_max),
+ ]:
+ if (
+ isinstance(val, bool)
+ or not isinstance(val, (int, float))
+ or not math.isfinite(val)
+ ):
+ raise ValueError(f"{name} must be a finite number")
+ if float(w_min) > float(w_max):
+ raise ValueError("w_min must be <= w_max")
+
+ if (
+ isinstance(neighborhood_radius, bool)
+ or not isinstance(neighborhood_radius, int)
+ or neighborhood_radius < 1
+ ):
+ raise ValueError("neighborhood_radius must be an integer >= 1")
+
+ self.c0 = float(c0)
+ self.c1 = float(c1)
+ self.w_min = float(w_min)
+ self.w_max = float(w_max)
+ self.neighborhood_radius = int(neighborhood_radius)
+ self.renewal: str = "acc"
+
+ def prepare_fit(self, context: FitContext) -> None:
+ self.renewal = context.renewal
+ def get_options(self) -> dict[str, Any]:
+ return {
+ "c0": self.c0,
+ "c1": self.c1,
+ "w_min": self.w_min,
+ "w_max": self.w_max,
+ "neighborhood_radius": self.neighborhood_radius,
+ }
+
+ def propose(
+ self, particle_idx: int, state: SwarmState, context: IterationContext
+ ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+ x = state.positions[particle_idx]
+ v = state.velocities[particle_idx]
+ pbest = state.pbest_positions[particle_idx]
+ device = x.device
+ dtype = x.dtype
+ n_particles = len(state.positions)
+
+ neighbors = []
+ for r in range(-self.neighborhood_radius, self.neighborhood_radius + 1):
+ idx = (particle_idx + r) % n_particles
+ if idx not in neighbors:
+ neighbors.append(idx)
+
+ renewal = (
+ context.optimizer.renewal
+ if getattr(context, "optimizer", None) is not None
+ else getattr(self, "renewal", "acc")
+ )
+
+ lbest_idx = None
+ lbest_score = None
+ for j in neighbors:
+ score_j = state.pbest_scores[j]
+ if _is_better_score(score_j, lbest_score, renewal):
+ lbest_score = score_j
+ lbest_idx = j
+
+ lbest = state.pbest_positions[lbest_idx]
+
+ r1 = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+ r2 = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+
+ cog = self.c0 * r1 * (pbest - x)
+ if not context.is_negative:
+ soc = self.c1 * r2 * (lbest - x)
+ else:
+ soc = -self.c1 * r2 * (lbest - x)
+
+ v_new = context.w * v + cog + soc
+ return None, v_new
+
+
+class QuantumMovement(MovementPlugin):
+ metadata = PluginMetadata(
+ stage="movement",
+ title="Quantum PSO",
+ source="10.1109/CEC.2004.1330875",
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def __init__(
+ self,
+ beta_min: float = 0.5,
+ beta_max: float = 1.0,
+ ):
+ for name, val in [("beta_min", beta_min), ("beta_max", beta_max)]:
+ if (
+ isinstance(val, bool)
+ or not isinstance(val, (int, float))
+ or not math.isfinite(val)
+ ):
+ raise ValueError(f"{name} must be a finite number")
+ if float(beta_min) > float(beta_max):
+ raise ValueError("beta_min must be <= beta_max")
+ if float(beta_min) < 0.0:
+ raise ValueError("beta_min must be >= 0.0")
+
+ self.beta_min = float(beta_min)
+ self.beta_max = float(beta_max)
+ self._mbest: torch.Tensor | None = None
+
+ def get_options(self) -> dict[str, Any]:
+ return {"beta_min": self.beta_min, "beta_max": self.beta_max}
+
+ def prepare_fit(self, context: FitContext) -> None:
+ if context.negative_swarm != 0.0:
+ raise ValueError("negative_swarm is unsupported for Quantum PSO")
+ if context.mutation_swarm != 0.0:
+ raise ValueError("mutation_swarm is unsupported for Quantum PSO")
+ if context.velocity_limit is not None:
+ raise ValueError("velocity_limit is unsupported for Quantum PSO")
+ self._mbest = None
+
+ def on_epoch_end(self, state: SwarmState, context: IterationContext) -> None:
+ if state.pbest_positions:
+ self._mbest = (
+ torch.stack(state.pbest_positions, dim=0).mean(dim=0).detach().clone()
+ )
+
+ def reset_particle_state(self, particle_idx: int) -> None:
+ pass
+
+ def propose(
+ self, particle_idx: int, state: SwarmState, context: IterationContext
+ ) -> tuple[torch.Tensor | None, torch.Tensor | None]:
+ if context.is_negative:
+ raise ValueError("negative_swarm is unsupported for Quantum PSO")
+
+ x = state.positions[particle_idx]
+ pbest = state.pbest_positions[particle_idx]
+ gbest = state.gbest_position
+ device = x.device
+ dtype = x.dtype
+
+ if self._mbest is None:
+ mbest = (
+ torch.stack(state.pbest_positions, dim=0).mean(dim=0).detach().clone()
+ )
+ else:
+ mbest = self._mbest.to(device=device, dtype=dtype)
+
+ if context.total_epochs <= 2:
+ beta = self.beta_max
+ else:
+ frac = (context.epoch - 1) / float(context.total_epochs - 2)
+ frac = max(0.0, min(1.0, frac))
+ beta = self.beta_max - (self.beta_max - self.beta_min) * frac
+
+ phi = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+ p = phi * pbest + (1.0 - phi) * gbest
+
+ u = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+ u = torch.clamp(u, min=1e-10, max=1.0)
+ ln_u_inv = torch.log(1.0 / u)
+
+ sign_rand = context.rng.uniform(x.shape, 0.0, 1.0, device=device, dtype=dtype)
+ sign = torch.where(sign_rand < 0.5, 1.0, -1.0)
+
+ delta = beta * torch.abs(mbest - x) * ln_u_inv
+ x_new = p + sign * delta
+
+ v_new = torch.zeros_like(x)
+ return x_new, v_new
+
+class ConvergencePlugin(BasePlugin):
+ def on_particle_evaluated(
+ self,
+ particle_idx: int,
+ score: tuple[float, float, float],
+ pbest_improved: bool,
+ context: IterationContext,
+ ) -> bool:
+ return False
+
+ def on_epoch_end(
+ self,
+ gbest_score: tuple[float, float, float],
+ gbest_improved: bool,
+ context: IterationContext,
+ ) -> bool:
+ return False
+
+ def reset_particle(self, particle_idx: int) -> None:
+ pass
+
+
+class NoConvergence(ConvergencePlugin):
+ metadata = PluginMetadata(
+ stage="convergence",
+ title="No Convergence Action",
+ source=None,
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+
+class ParticleResetConvergence(ConvergencePlugin):
+ metadata = PluginMetadata(
+ stage="convergence",
+ title="Particle Stagnation Reset",
+ source=None,
+ gradient_required=False,
+ fidelity="experimental",
+ )
+
+ def __init__(
+ self,
+ patience: int = 10,
+ min_delta: float = 0.0001,
+ monitor: str = "loss",
+ ):
+ if (
+ isinstance(patience, bool)
+ or not isinstance(patience, int)
+ or patience < 1
+ ):
+ raise ValueError("patience must be an integer >= 1")
+ if (
+ isinstance(min_delta, bool)
+ or not isinstance(min_delta, (int, float))
+ or not math.isfinite(min_delta)
+ or float(min_delta) < 0.0
+ ):
+ raise ValueError("min_delta must be a finite nonnegative number")
+ if monitor not in ("loss", "acc", "accuracy", "mse"):
+ raise ValueError("monitor must be one of 'loss', 'acc', 'accuracy', 'mse'")
+
+ self.patience = int(patience)
+ self.min_delta = float(min_delta)
+ self.monitor = monitor
+ self.patience_counters: list[int] = []
+ self.best_monitor_values: list[float | None] = []
+
+ def get_options(self) -> dict[str, Any]:
+ return {"patience": self.patience, "min_delta": self.min_delta, "monitor": self.monitor}
+
+ def prepare_fit(self, context: FitContext) -> None:
+ self.patience_counters = [0] * context.n_particles
+ self.best_monitor_values = [None] * context.n_particles
+
+ def reset_particle(self, particle_idx: int) -> None:
+ if particle_idx < len(self.patience_counters):
+ self.patience_counters[particle_idx] = 0
+ self.best_monitor_values[particle_idx] = None
+
+ def on_particle_evaluated(
+ self,
+ particle_idx: int,
+ score: tuple[float, float, float],
+ pbest_improved: bool,
+ context: IterationContext,
+ ) -> bool:
+ if self.monitor in ("acc", "accuracy"):
+ current_val = score[1]
+ elif self.monitor == "loss":
+ current_val = score[0]
+ elif self.monitor == "mse":
+ current_val = score[2]
+ else:
+ current_val = score[0]
+
+ if self.best_monitor_values[particle_idx] is None:
+ self.best_monitor_values[particle_idx] = current_val
+ self.patience_counters[particle_idx] = 0
+ return False
+
+ prev_val = self.best_monitor_values[particle_idx]
+ assert prev_val is not None
+ improved = False
+ if self.monitor in ("acc", "accuracy"):
+ delta = current_val - prev_val
+ improved = _is_at_least_delta(delta, self.min_delta)
+ else:
+ delta = prev_val - current_val
+ improved = _is_at_least_delta(delta, self.min_delta)
+
+ if improved:
+ self.best_monitor_values[particle_idx] = current_val
+ self.patience_counters[particle_idx] = 0
+ return False
+ else:
+ self.patience_counters[particle_idx] += 1
+ if self.patience_counters[particle_idx] >= self.patience:
+ return True
+ return False
+
+
+class EarlyStoppingConvergence(ConvergencePlugin):
+ metadata = PluginMetadata(
+ stage="convergence",
+ title="Global Best Early Stopping",
+ source=None,
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def __init__(
+ self,
+ patience: int = 10,
+ min_delta: float = 0.0001,
+ monitor: str = "loss",
+ ):
+ if (
+ isinstance(patience, bool)
+ or not isinstance(patience, int)
+ or patience < 1
+ ):
+ raise ValueError("patience must be an integer >= 1")
+ if (
+ isinstance(min_delta, bool)
+ or not isinstance(min_delta, (int, float))
+ or not math.isfinite(min_delta)
+ or float(min_delta) < 0.0
+ ):
+ raise ValueError("min_delta must be a finite nonnegative number")
+ if monitor not in ("loss", "acc", "accuracy", "mse"):
+ raise ValueError("monitor must be one of 'loss', 'acc', 'accuracy', 'mse'")
+
+ self.patience = int(patience)
+ self.min_delta = float(min_delta)
+ self.monitor = monitor
+ self.gbest_patience = 0
+ self.best_gbest_monitor: float | None = None
+
+ def get_options(self) -> dict[str, Any]:
+ return {"patience": self.patience, "min_delta": self.min_delta, "monitor": self.monitor}
+
+ def prepare_fit(self, context: FitContext) -> None:
+ self.gbest_patience = 0
+ self.best_gbest_monitor = None
+
+ def on_epoch_end(
+ self,
+ gbest_score: tuple[float, float, float],
+ gbest_improved: bool,
+ context: IterationContext,
+ ) -> bool:
+ if self.monitor in ("acc", "accuracy"):
+ current_val = gbest_score[1]
+ elif self.monitor == "loss":
+ current_val = gbest_score[0]
+ elif self.monitor == "mse":
+ current_val = gbest_score[2]
+ else:
+ current_val = gbest_score[0]
+
+ if self.best_gbest_monitor is None:
+ self.best_gbest_monitor = current_val
+ self.gbest_patience = 0
+ return False
+
+ if self.monitor in ("acc", "accuracy"):
+ delta = current_val - self.best_gbest_monitor
+ improved = _is_at_least_delta(delta, self.min_delta)
+ else:
+ delta = self.best_gbest_monitor - current_val
+ improved = _is_at_least_delta(delta, self.min_delta)
+
+ if improved:
+ self.best_gbest_monitor = current_val
+ self.gbest_patience = 0
+ return False
+ else:
+ self.gbest_patience += 1
+ if self.gbest_patience >= self.patience:
+ return True
+ return False
+
+
+class RefinementPlugin(BasePlugin):
+ def refine(
+ self,
+ gbest_position: torch.Tensor,
+ gbest_score: tuple[float, float, float],
+ eval_fn: Any,
+ context: FitContext,
+ ) -> tuple[torch.Tensor, tuple[float, float, float]]:
+ raise NotImplementedError
+
+
+class NoRefinement(RefinementPlugin):
+ metadata = PluginMetadata(
+ stage="refinement",
+ title="No Refinement",
+ source=None,
+ gradient_required=False,
+ fidelity="canonical",
+ )
+
+ def refine(
+ self,
+ gbest_position: torch.Tensor,
+ gbest_score: tuple[float, float, float],
+ eval_fn: Any,
+ context: FitContext,
+ ) -> tuple[torch.Tensor, tuple[float, float, float]]:
+ return gbest_position, gbest_score
+
+
+class AdamRefinement(RefinementPlugin):
+ metadata = PluginMetadata(
+ stage="refinement",
+ title="Adam Post-Search Refinement",
+ source="10.1016/j.amc.2006.07.025",
+ gradient_required=True,
+ fidelity="experimental",
+ )
+
+ def __init__(self, epochs: int = 10, lr: float = 0.001):
+ if (
+ isinstance(epochs, bool)
+ or not isinstance(epochs, int)
+ or epochs < 0
+ ):
+ raise ValueError("epochs must be an integer >= 0")
+ if (
+ isinstance(lr, bool)
+ or not isinstance(lr, (int, float))
+ or not math.isfinite(lr)
+ or float(lr) <= 0.0
+ ):
+ raise ValueError("lr must be a positive finite float")
+
+ self.epochs = int(epochs)
+ self.lr = float(lr)
+
+ def get_options(self) -> dict[str, Any]:
+ return {"epochs": self.epochs, "lr": self.lr}
+
+ def prepare_fit(self, context: FitContext) -> None:
+ if context.refinement_epochs > 0:
+ self.epochs = context.refinement_epochs
+ if context.refinement_lr > 0:
+ self.lr = context.refinement_lr
+
+ def refine(
+ self,
+ gbest_position: torch.Tensor,
+ gbest_score: tuple[float, float, float],
+ eval_fn: Any,
+ context: FitContext,
+ ) -> tuple[torch.Tensor, tuple[float, float, float]]:
+ if self.epochs <= 0:
+ return gbest_position, gbest_score
+
+ x_fit, y_fit = context.optimizer.evaluation_plugin.get_fitness_data(
+ context.x_train, context.y_train, context
+ )
+ optimizer = context.optimizer
+ optimizer._refine(
+ x_fit,
+ y_fit,
+ refinement_epochs=self.epochs,
+ refinement_lr=self.lr,
+ batch_size=context.batch_size,
+ renewal=context.renewal,
+ )
+ refined_score = optimizer.get_best_score()
+ if refined_score is not None and optimizer._global_best_weights is not None:
+ return optimizer._global_best_weights, refined_score
+ return gbest_position, gbest_score
+
+
+BUILTIN_PLUGINS: dict[str, dict[str, type[BasePlugin]]] = {
+ "movement": {
+ "original": OriginalMovement,
+ "inertia": InertiaMovement,
+ "constriction": ConstrictionMovement,
+ "fips": FIPSMovement,
+ "clpso": CLPSOMovement,
+ "bare_bones": BareBonesMovement,
+ "adaptive_moment": AdaptiveMomentMovement,
+ "local_best": RingLocalBestMovement,
+ "quantum": QuantumMovement,
+ },
+ "initialization": {
+ "model_noise": ModelNoiseInitialization,
+ "uniform": UniformInitialization,
+ },
+ "evaluation": {
+ "full": FullEvaluation,
+ "fixed_subset": FixedSubsetEvaluation,
+ },
+ "convergence": {
+ "none": NoConvergence,
+ "particle_reset": ParticleResetConvergence,
+ "early_stopping": EarlyStoppingConvergence,
+ },
+ "refinement": {
+ "none": NoRefinement,
+ "adam": AdamRefinement,
+ },
+}
+
+
+def available_plugins(stage: str | None = None) -> dict[str, Any]:
+ if stage is not None:
+ if stage not in BUILTIN_PLUGINS:
+ raise ValueError(
+ f"Unknown stage '{stage}'. Must be one of {list(BUILTIN_PLUGINS.keys())}"
+ )
+ return {
+ name: cls().metadata for name, cls in BUILTIN_PLUGINS[stage].items()
+ }
+ return {
+ s: {name: cls().metadata for name, cls in BUILTIN_PLUGINS[s].items()}
+ for s in BUILTIN_PLUGINS
+ }
+
+
+def get_plugin(
+ stage: str,
+ selector: str | BasePlugin,
+ options: dict[str, Any] | None = None,
+) -> BasePlugin:
+ if stage not in BUILTIN_PLUGINS:
+ raise ValueError(f"Unknown stage '{stage}'")
+ if isinstance(selector, BasePlugin):
+ plugin_copy = copy.deepcopy(selector)
+ if plugin_copy.metadata.stage != stage:
+ raise ValueError(
+ f"Plugin stage '{plugin_copy.metadata.stage}' does not match expected stage '{stage}'"
+ )
+ if options:
+ cls = type(plugin_copy)
+ sig = inspect.signature(cls.__init__)
+ valid_params = set(sig.parameters.keys()) - {"self"}
+ unknown_params = set(options.keys()) - valid_params
+ if unknown_params:
+ raise ValueError(
+ f"Unknown or incompatible option(s) {sorted(unknown_params)} for {stage} plugin '{plugin_copy.metadata.title}'"
+ )
+ return plugin_copy
+ if isinstance(selector, str):
+ if selector not in BUILTIN_PLUGINS[stage]:
+ raise ValueError(
+ f"Unknown {stage} plugin '{selector}'. Options: {list(BUILTIN_PLUGINS[stage].keys())}"
+ )
+ cls = BUILTIN_PLUGINS[stage][selector]
+ opts = options or {}
+ sig = inspect.signature(cls.__init__)
+ valid_params = set(sig.parameters.keys()) - {"self"}
+ unknown_params = set(opts.keys()) - valid_params
+ if unknown_params:
+ raise ValueError(
+ f"Unknown or incompatible option(s) {sorted(unknown_params)} for {stage} plugin '{selector}'. Valid options: {sorted(valid_params)}"
+ )
+ kwargs = {k: v for k, v in opts.items() if v is not None}
+ return cls(**kwargs)
+ raise TypeError(f"Invalid selector type {type(selector)} for stage '{stage}'")
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..bafebe3
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,67 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pso2keras"
+version = "4.0.0"
+description = "Particle Swarm Optimization for PyTorch models"
+readme = "README.md"
+requires-python = ">=3.10,<3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+ { name = "pieroot", email = "jgbong0306@gmail.com" }
+]
+keywords = [
+ "pso",
+ "pytorch",
+ "torch",
+ "optimization",
+ "particle swarm optimization",
+ "pso2keras",
+]
+classifiers = [
+ "Programming Language :: Python :: 3 :: Only",
+ "Programming Language :: Python :: 3.10",
+ "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+ "torch>=2.13,<3",
+ "numpy<2",
+ "scikit-learn",
+ "tqdm",
+ "tensorboard",
+ "tomli>=2; python_version < '3.11'",
+]
+
+[project.urls]
+Homepage = "https://github.com/jung-geun/PSO"
+Repository = "https://github.com/jung-geun/PSO"
+
+[project.optional-dependencies]
+examples = [
+ "pandas",
+ "ucimlrepo",
+ "torchvision>=0.28,<1",
+ "matplotlib>=3.8,<4",
+]
+detection = [
+ "ultralytics==8.4.142",
+ "ensemble-boxes==1.0.9",
+]
+
+[dependency-groups]
+dev = [
+ "pytest>=9,<10",
+ "build>=1.3,<2",
+ "twine>=6,<8",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["pso*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index 0e4ef99..0000000
--- a/requirements.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-ipython
-numpy
-pandas
-tensorflow==2.15.1
-tqdm==4.66.4
-scikit-learn==1.4.2
-tensorboard==2.15.1
\ No newline at end of file
diff --git a/setup.py b/setup.py
deleted file mode 100644
index b3152d8..0000000
--- a/setup.py
+++ /dev/null
@@ -1,41 +0,0 @@
-from setuptools import find_packages, setup
-
-import pso
-
-VERSION = pso.__version__
-
-
-def get_requirements(path: str):
- return [l.strip() for l in open(path)]
-
-
-setup(
- name="pso2keras",
- version=VERSION,
- description="Particle Swarm Optimization on tensorflow package",
- author="pieroot",
- author_email="jgbong0306@gmail.com",
- url="https://github.com/jung-geun/PSO",
- install_requires=get_requirements("requirements.txt"),
- packages=find_packages(exclude=[]),
- keywords=[
- "pso",
- "tensorflow",
- "keras",
- "optimization",
- "particle swarm optimization",
- "pso2keras",
- ],
- python_requires=">=3.10",
- package_data={},
- zip_safe=False,
- long_description=open("README.md", encoding="UTF8").read(),
- long_description_content_type="text/markdown",
- license="MIT",
- classifiers=[
- "License :: OSI Approved :: MIT License",
- "Programming Language :: Python :: 3 :: Only",
- "Programming Language :: Python :: 3.10",
- "Programming Language :: Python :: 3.11",
- ],
-)
diff --git a/test/bean.py b/test/bean.py
index 89c74b2..4d39b13 100644
--- a/test/bean.py
+++ b/test/bean.py
@@ -1,72 +1,138 @@
-import os
+"""Dry Bean dataset gradient baseline (PyTorch standard backprop optimizer, non-PSO)."""
-from keras.layers import Dense
-from keras.models import Sequential
-from keras.utils import to_categorical
+import copy
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, TensorDataset
from sklearn.model_selection import train_test_split
-from tensorflow import keras
+from sklearn.preprocessing import LabelEncoder
from ucimlrepo import fetch_ucirepo
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
-os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true"
+
+class BeanModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.net = nn.Sequential(
+ nn.Linear(16, 12),
+ nn.ReLU(),
+ nn.Linear(12, 8),
+ nn.ReLU(),
+ nn.Linear(8, 7),
+ )
+
+ def forward(self, x):
+ return self.net(x)
-def make_model():
- model = Sequential()
- model.add(Dense(12, input_dim=16, activation="relu"))
- model.add(Dense(8, activation="relu"))
- model.add(Dense(7, activation="softmax"))
-
- return model
-
-
-def get_data():
- # fetch dataset
+def get_data(seed: int = 42):
dry_bean_dataset = fetch_ucirepo(id=602)
-
- # data (as pandas dataframes)
X = dry_bean_dataset.data.features
y = dry_bean_dataset.data.targets
- x = X.to_numpy()
- # object to categorical
-
- x = x.astype("float32")
-
- y_class = to_categorical(y)
-
- # metadata
- # print(dry_bean_dataset.metadata)
-
- # variable information
- # print(dry_bean_dataset.variables)
-
- # print(X.head())
- # print(y.head())
- # y_class = to_categorical(y)
+ x = X.to_numpy().astype("float32")
+ encoder = LabelEncoder()
+ y_encoded = encoder.fit_transform(y.values.ravel()).astype("int64")
x_train, x_test, y_train, y_test = train_test_split(
- x, y_class, test_size=0.2, random_state=42, shuffle=True
+ x, y_encoded, test_size=0.2, random_state=seed, shuffle=True
+ )
+ return (
+ torch.tensor(x_train, dtype=torch.float32),
+ torch.tensor(x_test, dtype=torch.float32),
+ torch.tensor(y_train, dtype=torch.int64),
+ torch.tensor(y_test, dtype=torch.int64),
)
- return x_train, x_test, y_train, y_test
-x_train, x_test, y_train, y_test = get_data()
-model = make_model()
-early_stopping = keras.callbacks.EarlyStopping(
- patience=10, min_delta=0.001, restore_best_weights=True
-)
+def get_device() -> torch.device:
+ if (
+ hasattr(torch.backends, "mps")
+ and torch.backends.mps.is_built()
+ and torch.backends.mps.is_available()
+ ):
+ return torch.device("mps")
+ elif torch.cuda.is_available():
+ return torch.device("cuda")
+ return torch.device("cpu")
-model.compile(
- loss="sparse_categorical_crossentropy",
- optimizer="adam",
- metrics=["accuracy", "mse"],
-)
+def main():
+ torch.manual_seed(42)
+ np.random.seed(42)
-model.summary()
+ device = get_device()
+ print(f"Selected device: {device}")
-history = model.fit(
- x_train, y_train, epochs=150, batch_size=10, callbacks=[early_stopping]
-)
-score = model.evaluate(x_test, y_test, verbose=2)
+ x_train, x_test, y_train, y_test = get_data(seed=42)
+ train_dataset = TensorDataset(x_train, y_train)
+ val_dataset = TensorDataset(x_test, y_test)
+ train_loader = DataLoader(train_dataset, batch_size=10, shuffle=True)
+ val_loader = DataLoader(val_dataset, batch_size=10, shuffle=False)
+
+ model = BeanModel().to(device)
+ optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+ criterion = nn.CrossEntropyLoss()
+
+ best_val_loss = float("inf")
+ best_state = None
+ patience = 10
+ min_delta = 0.001
+ patience_counter = 0
+
+ for epoch in range(150):
+ model.train()
+ for bx, by in train_loader:
+ bx, by = bx.to(device), by.to(device)
+ optimizer.zero_grad()
+ out = model(bx)
+ loss = criterion(out, by)
+ loss.backward()
+ optimizer.step()
+
+ model.eval()
+ val_loss = 0.0
+ total = 0
+ with torch.no_grad():
+ for bx, by in val_loader:
+ bx, by = bx.to(device), by.to(device)
+ out = model(bx)
+ loss = criterion(out, by)
+ val_loss += loss.item() * bx.size(0)
+ total += bx.size(0)
+
+ val_loss /= total
+
+ if val_loss < best_val_loss - min_delta:
+ best_val_loss = val_loss
+ best_state = copy.deepcopy(model.state_dict())
+ patience_counter = 0
+ else:
+ patience_counter += 1
+ if patience_counter >= patience:
+ break
+
+ if best_state is not None:
+ model.load_state_dict(best_state)
+
+ model.eval()
+ test_loss = 0.0
+ correct = 0
+ total = 0
+ with torch.no_grad():
+ for bx, by in val_loader:
+ bx, by = bx.to(device), by.to(device)
+ out = model(bx)
+ loss = criterion(out, by)
+ test_loss += loss.item() * bx.size(0)
+ preds = out.argmax(dim=1)
+ correct += (preds == by).sum().item()
+ total += bx.size(0)
+
+ test_loss /= total
+ test_acc = correct / total
+ print(f"Final test loss: {test_loss:.4f}, accuracy: {test_acc:.4f}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/benchmark_suite.py b/test/benchmark_suite.py
new file mode 100644
index 0000000..7c81f52
--- /dev/null
+++ b/test/benchmark_suite.py
@@ -0,0 +1,1733 @@
+import argparse
+import csv
+import datetime
+import hashlib
+import json
+import math
+import os
+import platform
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+from sklearn.datasets import load_digits, load_iris
+from sklearn.decomposition import PCA
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+
+from pso import Optimizer, __version__ as pso_version
+
+BENCHMARK_PROTOCOL_VERSION = "2.0.0"
+
+METHOD_STYLE: Dict[str, Dict[str, str]] = {
+ "original": {"color": "#E69F00", "hatch": ""},
+ "inertia": {"color": "#56B4E9", "hatch": "//"},
+ "constriction": {"color": "#009E73", "hatch": "\\\\"},
+ "fips": {"color": "#F0E442", "hatch": "xx"},
+ "clpso": {"color": "#0072B2", "hatch": ".."},
+ "bare_bones": {"color": "#D55E00", "hatch": "++"},
+ "adaptive_moment": {"color": "#CC79A7", "hatch": "||"},
+}
+
+FALLBACK_COLORS = ["#E69F00", "#56B4E9", "#009E73", "#F0E442", "#0072B2", "#D55E00", "#CC79A7"]
+FALLBACK_HATCHES = ["", "//", "\\\\", "xx", "..", "++", "||"]
+
+
+def get_method_style(method_name: str, idx: int = 0) -> Tuple[str, str]:
+ if method_name in METHOD_STYLE:
+ return METHOD_STYLE[method_name]["color"], METHOD_STYLE[method_name]["hatch"]
+ c = FALLBACK_COLORS[idx % len(FALLBACK_COLORS)]
+ h = FALLBACK_HATCHES[idx % len(FALLBACK_HATCHES)]
+ return c, h
+# Student's t critical values for 95% 2-tailed confidence intervals (df -> t_crit)
+T_TABLE = {
+ 1: 12.7062,
+ 2: 4.3027,
+ 3: 3.1824,
+ 4: 2.7764,
+ 5: 2.5706,
+ 6: 2.4469,
+ 7: 2.3646,
+ 8: 2.3060,
+ 9: 2.2622,
+ 10: 2.2281,
+ 15: 2.1314,
+ 20: 2.0860,
+ 30: 2.0423,
+ 60: 2.0003,
+ 120: 1.9799,
+}
+
+
+def get_t_crit(df: int) -> float:
+ if df <= 0:
+ return 0.0
+ if df in T_TABLE:
+ return T_TABLE[df]
+ keys = sorted(T_TABLE.keys())
+ if df < keys[0]:
+ return T_TABLE[keys[0]]
+ if df > keys[-1]:
+ return 1.96
+ for i in range(len(keys) - 1):
+ if keys[i] <= df <= keys[i + 1]:
+ k0, k1 = keys[i], keys[i + 1]
+ v0, v1 = T_TABLE[k0], T_TABLE[k1]
+ return v0 + (v1 - v0) * (df - k0) / (k1 - k0)
+ return 1.96
+
+
+def calc_stats(vals: List[float]) -> Dict[str, float]:
+ arr = np.array(vals, dtype=float)
+ n = len(arr)
+ if n == 0:
+ return {"mean": 0.0, "std": 0.0, "median": 0.0, "iqr": 0.0, "ci95_t": 0.0}
+ mean_val = float(np.mean(arr))
+ std_val = float(np.std(arr, ddof=1)) if n > 1 else 0.0
+ med_val = float(np.median(arr))
+ if n > 1:
+ q75, q25 = np.percentile(arr, [75, 25])
+ iqr_val = float(q75 - q25)
+ else:
+ iqr_val = 0.0
+ t_crit = get_t_crit(n - 1)
+ ci95 = float(t_crit * std_val / math.sqrt(n)) if n > 0 else 0.0
+ return {
+ "mean": round(mean_val, 6),
+ "std": round(std_val, 6),
+ "median": round(med_val, 6),
+ "iqr": round(iqr_val, 6),
+ "ci95_t": round(ci95, 6),
+ }
+
+
+# ==========================================
+# Data Loaders & Model Factories
+# ==========================================
+
+def get_xor_data(seed: int = 41) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+ x = torch.tensor([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]], dtype=torch.float32)
+ y = torch.tensor([[0.0], [1.0], [1.0], [0.0]], dtype=torch.float32)
+ return x, x, y, y
+
+
+def make_xor_model(seed: int = 41) -> nn.Module:
+ torch.manual_seed(seed)
+ return nn.Sequential(
+ nn.Linear(2, 4),
+ nn.Tanh(),
+ nn.Linear(4, 1),
+ )
+
+
+def get_iris_data(seed: int = 41) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+ iris = load_iris()
+ x = iris.data.astype("float32")
+ y = iris.target.astype("int64")
+
+ x_train, x_test, y_train, y_test = train_test_split(
+ x, y, test_size=0.2, shuffle=True, stratify=y, 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(x_test, dtype=torch.float32),
+ torch.tensor(y_train, dtype=torch.int64),
+ torch.tensor(y_test, dtype=torch.int64),
+ )
+
+
+def make_iris_model(seed: int = 41) -> nn.Module:
+ torch.manual_seed(seed)
+ return nn.Sequential(
+ nn.Linear(4, 10),
+ nn.ReLU(),
+ nn.Linear(10, 10),
+ nn.ReLU(),
+ nn.Linear(10, 3),
+ )
+
+
+def get_seeds_data(seed: int = 41) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+ seeds_path = Path("data/seeds/seeds_dataset.txt")
+ if not seeds_path.exists():
+ raise FileNotFoundError(f"Seeds dataset not found at {seeds_path}")
+
+ with open(seeds_path, "r", encoding="utf-8") as f:
+ lines = f.readlines()
+
+ rows = []
+ for line in lines:
+ parts = line.strip().split()
+ if parts:
+ rows.append([float(p) for p in parts])
+
+ data = np.array(rows, dtype=np.float32)
+ x = data[:, :-1]
+ y = (data[:, -1] - 1).astype(np.int64)
+
+ x_train, x_test, y_train, y_test = train_test_split(
+ 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(x_test, dtype=torch.float32),
+ torch.tensor(y_train, dtype=torch.int64),
+ torch.tensor(y_test, dtype=torch.int64),
+ )
+
+
+def make_seeds_model(seed: int = 41) -> nn.Module:
+ torch.manual_seed(seed)
+ return nn.Sequential(
+ nn.Linear(7, 16),
+ nn.ReLU(),
+ nn.Linear(16, 32),
+ nn.ReLU(),
+ nn.Linear(32, 3),
+ )
+
+
+def get_digits_data(seed: int = 41) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+ digits = load_digits()
+ x = digits.data.astype("float32")
+ y = digits.target.astype("int64")
+
+ x_train, x_test, y_train, y_test = train_test_split(
+ 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(x_test, dtype=torch.float32),
+ torch.tensor(y_train, dtype=torch.int64),
+ torch.tensor(y_test, dtype=torch.int64),
+ )
+
+
+def make_digits_model(seed: int = 41) -> nn.Module:
+ torch.manual_seed(seed)
+ return nn.Sequential(
+ nn.Linear(64, 12),
+ nn.ReLU(),
+ nn.Linear(12, 10),
+ nn.ReLU(),
+ nn.Linear(10, 10),
+ )
+
+
+def get_mnist_data(seed: int = 41) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+ from torchvision.datasets import MNIST
+
+ cache_dir = Path("result/cache")
+ cache_dir.mkdir(parents=True, exist_ok=True)
+
+ train_dataset = MNIST(root=str(cache_dir), train=True, download=True)
+ test_dataset = MNIST(root=str(cache_dir), train=False, download=True)
+
+ x_train_raw = (train_dataset.data[:3000].float() / 255.0).reshape(3000, -1).numpy()
+ y_train = train_dataset.targets[:3000].long()
+
+ x_test_raw = (test_dataset.data[:1000].float() / 255.0).reshape(1000, -1).numpy()
+ y_test = test_dataset.targets[:1000].long()
+
+ pca = PCA(n_components=32, whiten=True, random_state=seed)
+ x_train_pca = pca.fit_transform(x_train_raw)
+ x_test_pca = pca.transform(x_test_raw)
+
+ return (
+ torch.tensor(x_train_pca, dtype=torch.float32),
+ torch.tensor(x_test_pca, dtype=torch.float32),
+ y_train,
+ y_test,
+ )
+
+
+def make_mnist_model(seed: int = 41) -> nn.Module:
+ torch.manual_seed(seed)
+ return nn.Linear(32, 10)
+
+
+DATASET_CACHE: Dict[Tuple[str, int], Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]] = {}
+
+
+def get_cached_dataset(
+ ds_name: str, seed: int
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+ key = (ds_name, seed)
+ if key not in DATASET_CACHE:
+ loader = WORKLOADS[ds_name]["data_loader"]
+ DATASET_CACHE[key] = loader(seed=seed)
+ return DATASET_CACHE[key]
+
+
+def compute_data_fingerprint(
+ x_train: torch.Tensor, x_test: torch.Tensor, y_train: torch.Tensor, y_test: torch.Tensor
+) -> str:
+ h = hashlib.sha256()
+ for t in (x_train, x_test, y_train, y_test):
+ h.update(t.detach().cpu().numpy().tobytes())
+ return h.hexdigest()[:16]
+
+
+def compute_model_fingerprint(model: nn.Module) -> str:
+ h = hashlib.sha256()
+ for p in model.parameters():
+ h.update(p.detach().cpu().numpy().tobytes())
+ return h.hexdigest()[:16]
+
+
+def get_hardware_provenance(device: torch.device) -> Dict[str, Any]:
+ prov: Dict[str, Any] = {
+ "platform": platform.platform(),
+ "system": platform.system(),
+ "machine": platform.machine(),
+ "processor": platform.processor(),
+ "python_version": sys.version.split()[0],
+ "torch_version": torch.__version__,
+ "pso_version": pso_version,
+ "device_type": device.type,
+ "device_str": str(device),
+ }
+ if device.type == "cuda" and torch.cuda.is_available():
+ prov["cuda_device_name"] = torch.cuda.get_device_name(device)
+ elif device.type == "mps" and hasattr(torch.backends, "mps"):
+ prov["mps_available"] = torch.backends.mps.is_available()
+ return prov
+
+
+def extract_plugin_metadata(opt: Optimizer) -> Dict[str, Any]:
+ return {
+ "movement": {
+ "title": opt.movement_plugin.metadata.title,
+ "source": opt.movement_plugin.metadata.source,
+ "fidelity": opt.movement_plugin.metadata.fidelity,
+ "gradient_required": opt.movement_plugin.metadata.gradient_required,
+ "options": opt.movement_plugin.get_options(),
+ },
+ "initialization": {
+ "title": opt.initialization_plugin.metadata.title,
+ "source": opt.initialization_plugin.metadata.source,
+ "fidelity": opt.initialization_plugin.metadata.fidelity,
+ "gradient_required": opt.initialization_plugin.metadata.gradient_required,
+ "options": opt.initialization_plugin.get_options(),
+ },
+ "evaluation": {
+ "title": opt.evaluation_plugin.metadata.title,
+ "source": opt.evaluation_plugin.metadata.source,
+ "fidelity": opt.evaluation_plugin.metadata.fidelity,
+ "gradient_required": opt.evaluation_plugin.metadata.gradient_required,
+ "options": opt.evaluation_plugin.get_options(),
+ },
+ "convergence": {
+ "title": opt.convergence_plugin.metadata.title,
+ "source": opt.convergence_plugin.metadata.source,
+ "fidelity": opt.convergence_plugin.metadata.fidelity,
+ "gradient_required": opt.convergence_plugin.metadata.gradient_required,
+ "options": opt.convergence_plugin.get_options(),
+ },
+ "refinement": {
+ "title": opt.refinement_plugin.metadata.title,
+ "source": opt.refinement_plugin.metadata.source,
+ "fidelity": opt.refinement_plugin.metadata.fidelity,
+ "gradient_required": opt.refinement_plugin.metadata.gradient_required,
+ "options": opt.refinement_plugin.get_options(),
+ },
+ }
+
+
+WORKLOADS = {
+ "XOR": {
+ "task": "binary",
+ "loss_fn": lambda: nn.BCEWithLogitsLoss(),
+ "model_factory": make_xor_model,
+ "data_loader": get_xor_data,
+ "n_particles": 24,
+ "epochs": 80,
+ "evaluation": "full",
+ "fitness_size": None,
+ "batch_size": None,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "initial_position_noise": 1.0,
+ "renewal": "loss",
+ "held_out": False,
+ "pca_config": None,
+ },
+ "Iris": {
+ "task": "multiclass",
+ "loss_fn": lambda: nn.CrossEntropyLoss(),
+ "model_factory": make_iris_model,
+ "data_loader": get_iris_data,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": None,
+ "batch_size": None,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "held_out": True,
+ "pca_config": None,
+ },
+ "Seeds": {
+ "task": "multiclass",
+ "loss_fn": lambda: nn.CrossEntropyLoss(),
+ "model_factory": make_seeds_model,
+ "data_loader": get_seeds_data,
+ "n_particles": 24,
+ "epochs": 60,
+ "evaluation": "full",
+ "fitness_size": None,
+ "batch_size": None,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.5,
+ "renewal": "loss",
+ "held_out": True,
+ "pca_config": None,
+ },
+ "Digits": {
+ "task": "multiclass",
+ "loss_fn": lambda: nn.CrossEntropyLoss(),
+ "model_factory": make_digits_model,
+ "data_loader": get_digits_data,
+ "n_particles": 24,
+ "epochs": 50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 1000,
+ "batch_size": 250,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.25,
+ "renewal": "loss",
+ "held_out": True,
+ "pca_config": None,
+ },
+ "MNIST": {
+ "task": "multiclass",
+ "loss_fn": lambda: nn.CrossEntropyLoss(),
+ "model_factory": make_mnist_model,
+ "data_loader": get_mnist_data,
+ "n_particles": 30,
+ "epochs": 80,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "initial_position_noise": 0.05,
+ "renewal": "loss",
+ "held_out": True,
+ "pca_config": {"n_components": 32, "whiten": True},
+ },
+}
+
+MAIN_METHODS = ["original", "inertia", "constriction", "fips", "clpso", "bare_bones", "adaptive_moment"]
+
+ABLATION_PROFILES = {
+ "inertia_canonical": {
+ "method": "inertia",
+ "c0": 2.0,
+ "c1": 2.0,
+ "w_min": 0.4,
+ "w_max": 0.9,
+ "velocity_limit_ratio": 0.1,
+ "mutation_swarm": 0.0,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ },
+ "inertia_tuned": {
+ "method": "inertia",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ },
+ "tuned_no_mutation": {
+ "method": "inertia",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.0,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ },
+ "tuned_full_evaluation": {
+ "method": "inertia",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "evaluation": "full",
+ "fitness_size": None,
+ "batch_size": None,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ },
+ "tuned_uniform_initialization": {
+ "method": "inertia",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "initialization": "uniform",
+ "convergence": "none",
+ "refinement": "none",
+ },
+ "tuned_particle_reset": {
+ "method": "inertia",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "initialization": "model_noise",
+ "convergence": "particle_reset",
+ "convergence_patience": 10,
+ "convergence_min_delta": 0.0001,
+ "refinement": "none",
+ },
+ "tuned_adam_100_lr.01": {
+ "method": "inertia",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "adam",
+ "refinement_epochs": 100,
+ "refinement_lr": 0.01,
+ },
+ "adaptive_moment_.10": {
+ "method": "adaptive_moment",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "moment_blend": 0.10,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ },
+ "adaptive_moment_.25": {
+ "method": "adaptive_moment",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "moment_blend": 0.25,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ },
+ "adaptive_moment_.50": {
+ "method": "adaptive_moment",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w_min": 0.7298,
+ "w_max": 0.7298,
+ "velocity_limit_ratio": 0.025,
+ "mutation_swarm": 0.02,
+ "moment_blend": 0.50,
+ "evaluation": "fixed_subset",
+ "fitness_size": 2000,
+ "batch_size": 1000,
+ "initialization": "model_noise",
+ "convergence": "none",
+ "refinement": "none",
+ },
+}
+
+
+def sync_device(device: torch.device):
+ if device.type == "cuda":
+ torch.cuda.synchronize(device)
+ elif device.type == "mps" and hasattr(torch.mps, "synchronize"):
+ torch.mps.synchronize()
+
+
+def resolve_execution_device(user_device: Optional[str] = None) -> torch.device:
+ if user_device:
+ dev = torch.device(user_device)
+ if dev.type == "cuda" and not torch.cuda.is_available():
+ raise RuntimeError("CUDA requested but not available.")
+ if dev.type == "mps":
+ built = hasattr(torch.backends, "mps") and torch.backends.mps.is_built()
+ avail = hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+ if not (built and avail):
+ raise RuntimeError("MPS requested but not available.")
+ return dev
+ else:
+ if (
+ hasattr(torch.backends, "mps")
+ and torch.backends.mps.is_built()
+ and torch.backends.mps.is_available()
+ ):
+ return torch.device("mps")
+ elif torch.cuda.is_available():
+ return torch.device("cuda")
+ else:
+ return torch.device("cpu")
+
+
+def compute_summaries_and_ranks(runs: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
+ main_runs = [r for r in runs if r.get("type") == "main" and r.get("completed")]
+ ablation_runs = [r for r in runs if r.get("type") == "ablation" and r.get("completed")]
+
+ def process_group(group_runs: List[Dict[str, Any]], is_ablation: bool = False) -> List[Dict[str, Any]]:
+ grouped: Dict[Tuple[str, str], List[Dict[str, Any]]] = {}
+ for r in group_runs:
+ ds = r["dataset"]
+ method_key = r["profile"] if is_ablation else r["method"]
+ key = (ds, method_key)
+ if key not in grouped:
+ grouped[key] = []
+ grouped[key].append(r)
+
+ summaries = []
+ for (ds, m_key), r_list in grouped.items():
+ eval_accs = [r["eval_metrics"]["accuracy"] for r in r_list]
+ eval_losses = [r["eval_metrics"]["loss"] for r in r_list]
+ eval_mses = [r["eval_metrics"]["mse"] for r in r_list]
+ train_accs = [r["train_metrics"]["accuracy"] for r in r_list]
+ train_losses = [r["train_metrics"]["loss"] for r in r_list]
+ runtimes = [r["runtime_seconds"] for r in r_list]
+
+ first_run = r_list[0]
+ summary_entry = {
+ "dataset": ds,
+ "method" if not is_ablation else "profile": m_key,
+ "method_name": first_run["method"],
+ "n_particles": first_run["n_particles"],
+ "epochs": first_run["epochs"],
+ "n_runs": len(r_list),
+ "eval_acc": calc_stats(eval_accs),
+ "eval_loss": calc_stats(eval_losses),
+ "eval_mse": calc_stats(eval_mses),
+ "train_acc": calc_stats(train_accs),
+ "train_loss": calc_stats(train_losses),
+ "runtime_seconds": calc_stats(runtimes),
+ }
+ summaries.append(summary_entry)
+
+ # Compute per-dataset ranks
+ datasets = sorted(list(set(s["dataset"] for s in summaries)))
+ for ds in datasets:
+ ds_items = [s for s in summaries if s["dataset"] == ds]
+ ds_items.sort(
+ key=lambda s: (
+ -s["eval_acc"]["mean"],
+ s["eval_loss"]["mean"],
+ s["eval_mse"]["mean"],
+ )
+ )
+ for rank_idx, item in enumerate(ds_items, start=1):
+ item["rank_acc"] = rank_idx
+
+ ds_items.sort(
+ key=lambda s: (
+ s["eval_loss"]["mean"],
+ -s["eval_acc"]["mean"],
+ s["eval_mse"]["mean"],
+ )
+ )
+ for rank_idx, item in enumerate(ds_items, start=1):
+ item["rank_loss"] = rank_idx
+
+ return summaries
+
+ return {
+ "main": process_group(main_runs, is_ablation=False),
+ "ablation": process_group(ablation_runs, is_ablation=True),
+ }
+
+
+def save_json_atomic(data: Dict[str, Any], json_path: Path):
+ json_path.parent.mkdir(parents=True, exist_ok=True)
+ tmp_path = json_path.with_suffix(".json.tmp")
+ with open(tmp_path, "w", encoding="utf-8") as f:
+ json.dump(data, f, indent=2)
+ tmp_path.replace(json_path)
+
+
+def write_csv_reports(summaries: Dict[str, List[Dict[str, Any]]], main_csv_path: Path, ablation_csv_path: Path):
+ main_csv_path.parent.mkdir(parents=True, exist_ok=True)
+ ablation_csv_path.parent.mkdir(parents=True, exist_ok=True)
+
+ fieldnames_main = [
+ "dataset",
+ "method",
+ "n_particles",
+ "epochs",
+ "n_seeds",
+ "eval_acc_mean",
+ "eval_acc_std",
+ "eval_acc_median",
+ "eval_acc_iqr",
+ "eval_acc_ci95",
+ "eval_loss_mean",
+ "eval_loss_std",
+ "eval_loss_median",
+ "eval_loss_iqr",
+ "eval_loss_ci95",
+ "eval_mse_mean",
+ "eval_mse_std",
+ "train_acc_mean",
+ "train_loss_mean",
+ "runtime_seconds_mean",
+ "runtime_seconds_std",
+ "rank_acc",
+ "rank_loss",
+ ]
+
+ with open(main_csv_path, "w", newline="", encoding="utf-8") as f:
+ writer = csv.DictWriter(f, fieldnames=fieldnames_main)
+ writer.writeheader()
+ for s in sorted(summaries["main"], key=lambda x: (x["dataset"], x["method"])):
+ writer.writerow(
+ {
+ "dataset": s["dataset"],
+ "method": s["method"],
+ "n_particles": s["n_particles"],
+ "epochs": s["epochs"],
+ "n_seeds": s["n_runs"],
+ "eval_acc_mean": s["eval_acc"]["mean"],
+ "eval_acc_std": s["eval_acc"]["std"],
+ "eval_acc_median": s["eval_acc"]["median"],
+ "eval_acc_iqr": s["eval_acc"]["iqr"],
+ "eval_acc_ci95": s["eval_acc"]["ci95_t"],
+ "eval_loss_mean": s["eval_loss"]["mean"],
+ "eval_loss_std": s["eval_loss"]["std"],
+ "eval_loss_median": s["eval_loss"]["median"],
+ "eval_loss_iqr": s["eval_loss"]["iqr"],
+ "eval_loss_ci95": s["eval_loss"]["ci95_t"],
+ "eval_mse_mean": s["eval_mse"]["mean"],
+ "eval_mse_std": s["eval_mse"]["std"],
+ "train_acc_mean": s["train_acc"]["mean"],
+ "train_loss_mean": s["train_loss"]["mean"],
+ "runtime_seconds_mean": s["runtime_seconds"]["mean"],
+ "runtime_seconds_std": s["runtime_seconds"]["std"],
+ "rank_acc": s.get("rank_acc", 0),
+ "rank_loss": s.get("rank_loss", 0),
+ }
+ )
+
+ fieldnames_ablation = [
+ "profile",
+ "dataset",
+ "method",
+ "n_particles",
+ "epochs",
+ "n_seeds",
+ "eval_acc_mean",
+ "eval_acc_std",
+ "eval_acc_median",
+ "eval_acc_iqr",
+ "eval_acc_ci95",
+ "eval_loss_mean",
+ "eval_loss_std",
+ "eval_loss_median",
+ "eval_loss_iqr",
+ "eval_loss_ci95",
+ "eval_mse_mean",
+ "eval_mse_std",
+ "train_acc_mean",
+ "train_loss_mean",
+ "runtime_seconds_mean",
+ "runtime_seconds_std",
+ "rank_acc",
+ "rank_loss",
+ ]
+
+ with open(ablation_csv_path, "w", newline="", encoding="utf-8") as f:
+ writer = csv.DictWriter(f, fieldnames=fieldnames_ablation)
+ writer.writeheader()
+ for s in sorted(summaries["ablation"], key=lambda x: (x["dataset"], x["profile"])):
+ writer.writerow(
+ {
+ "profile": s["profile"],
+ "dataset": s["dataset"],
+ "method": s["method_name"],
+ "n_particles": s["n_particles"],
+ "epochs": s["epochs"],
+ "n_seeds": s["n_runs"],
+ "eval_acc_mean": s["eval_acc"]["mean"],
+ "eval_acc_std": s["eval_acc"]["std"],
+ "eval_acc_median": s["eval_acc"]["median"],
+ "eval_acc_iqr": s["eval_acc"]["iqr"],
+ "eval_acc_ci95": s["eval_acc"]["ci95_t"],
+ "eval_loss_mean": s["eval_loss"]["mean"],
+ "eval_loss_std": s["eval_loss"]["std"],
+ "eval_loss_median": s["eval_loss"]["median"],
+ "eval_loss_iqr": s["eval_loss"]["iqr"],
+ "eval_loss_ci95": s["eval_loss"]["ci95_t"],
+ "eval_mse_mean": s["eval_mse"]["mean"],
+ "eval_mse_std": s["eval_mse"]["std"],
+ "train_acc_mean": s["train_acc"]["mean"],
+ "train_loss_mean": s["train_loss"]["mean"],
+ "runtime_seconds_mean": s["runtime_seconds"]["mean"],
+ "runtime_seconds_std": s["runtime_seconds"]["std"],
+ "rank_acc": s.get("rank_acc", 0),
+ "rank_loss": s.get("rank_loss", 0),
+ }
+ )
+
+
+def render_plots(summaries: Dict[str, List[Dict[str, Any]]], figure_dir: Path):
+ from matplotlib.patches import Patch
+
+ figure_dir.mkdir(parents=True, exist_ok=True)
+ plt.rcParams.update({"font.size": 11, "figure.autolayout": True})
+
+ main_sums = summaries.get("main", [])
+ n_seeds = max([s.get("n_runs", 5) for s in main_sums]) if main_sums else 5
+ present_datasets = {s["dataset"] for s in main_sums}
+ datasets = [name for name in WORKLOADS if name in present_datasets]
+ methods = [m for m in MAIN_METHODS if any(s["method"] == m for s in main_sums)] if main_sums else []
+ if main_sums and not methods:
+ methods = sorted(list(set(s["method"] for s in main_sums)))
+
+ # 1. Accuracy Plot (pso_v4_accuracy.png)
+ if main_sums and datasets and methods:
+ fig, ax = plt.subplots(figsize=(10, 6))
+ x = np.arange(len(datasets))
+ width = 0.8 / max(1, len(methods))
+
+ for i, m in enumerate(methods):
+ means = []
+ yerrs = []
+ for ds in datasets:
+ match = [s for s in main_sums if s["dataset"] == ds and s["method"] == m]
+ if match:
+ means.append(match[0]["eval_acc"]["mean"])
+ yerrs.append(match[0]["eval_acc"]["std"])
+ else:
+ means.append(np.nan)
+ yerrs.append(np.nan)
+
+ offset = x - 0.4 + width * i + width / 2
+ col, hatch = get_method_style(m, i)
+ ax.bar(
+ offset,
+ means,
+ width,
+ yerr=yerrs,
+ label=m,
+ color=col,
+ hatch=hatch,
+ edgecolor="black",
+ linewidth=0.7,
+ capsize=3,
+ )
+
+ ax.set_ylabel("Evaluation Accuracy")
+ ax.set_title(f"PSO Benchmark Evaluation Accuracy by Workload\n(mean ± 1 SD, n={n_seeds}; XOR=train, others=held-out)")
+ ax.set_xticks(x)
+ ax.set_xticklabels(datasets)
+ ax.set_ylim(0, 1.05)
+ ax.legend(title="Method", bbox_to_anchor=(1.04, 1), loc="upper left")
+ ax.grid(axis="y", linestyle="--", alpha=0.5)
+ fig.savefig(figure_dir / "pso_v4_accuracy.png", dpi=200, bbox_inches="tight")
+ plt.close(fig)
+
+ # 2. Loss Plot (pso_v4_loss.png)
+ if main_sums and datasets and methods:
+ fig, ax = plt.subplots(figsize=(10, 6))
+ x = np.arange(len(datasets))
+ width = 0.8 / max(1, len(methods))
+
+ for i, m in enumerate(methods):
+ means = []
+ lower_errs = []
+ upper_errs = []
+ for ds in datasets:
+ match = [s for s in main_sums if s["dataset"] == ds and s["method"] == m]
+ if match:
+ m_val = match[0]["eval_loss"]["mean"]
+ s_val = match[0]["eval_loss"]["std"]
+ means.append(m_val)
+ lower_errs.append(min(s_val, max(0.0, m_val - 1e-6)))
+ upper_errs.append(s_val)
+ else:
+ means.append(np.nan)
+ lower_errs.append(np.nan)
+ upper_errs.append(np.nan)
+
+ offset = x - 0.4 + width * i + width / 2
+ col, hatch = get_method_style(m, i)
+ yerr = [lower_errs, upper_errs]
+ ax.bar(
+ offset,
+ means,
+ width,
+ yerr=yerr,
+ label=m,
+ color=col,
+ hatch=hatch,
+ edgecolor="black",
+ linewidth=0.7,
+ capsize=3,
+ )
+
+ ax.set_yscale("log")
+ ax.set_ylabel("Evaluation Loss (log scale)")
+ ax.set_title(f"PSO Benchmark Evaluation Loss by Workload\n(mean ± 1 SD, n={n_seeds}; XOR=train, others=held-out)")
+ ax.set_xticks(x)
+ ax.set_xticklabels(datasets)
+ ax.legend(title="Method", bbox_to_anchor=(1.04, 1), loc="upper left")
+ ax.grid(axis="y", linestyle="--", alpha=0.5)
+ fig.savefig(figure_dir / "pso_v4_loss.png", dpi=200, bbox_inches="tight")
+ plt.close(fig)
+
+ # 3. Runtime Plot (pso_v4_runtime.png)
+ if main_sums and datasets and methods:
+ fig, ax = plt.subplots(figsize=(10, 6))
+ x = np.arange(len(datasets))
+ width = 0.8 / max(1, len(methods))
+
+ for i, m in enumerate(methods):
+ means = []
+ yerrs = []
+ for ds in datasets:
+ match = [s for s in main_sums if s["dataset"] == ds and s["method"] == m]
+ if match:
+ means.append(match[0]["runtime_seconds"]["mean"])
+ yerrs.append(match[0]["runtime_seconds"]["std"])
+ else:
+ means.append(np.nan)
+ yerrs.append(np.nan)
+
+ offset = x - 0.4 + width * i + width / 2
+ col, hatch = get_method_style(m, i)
+ ax.bar(
+ offset,
+ means,
+ width,
+ yerr=yerrs,
+ label=m,
+ color=col,
+ hatch=hatch,
+ edgecolor="black",
+ linewidth=0.7,
+ capsize=3,
+ )
+
+ ax.set_ylabel("Fit Runtime (seconds)")
+ ax.set_title(f"PSO Benchmark Fit Runtime by Workload\n(mean ± 1 SD, n={n_seeds}; fit-only after warmup)")
+ ax.set_xticks(x)
+ ax.set_xticklabels(datasets)
+ ax.legend(title="Method", bbox_to_anchor=(1.04, 1), loc="upper left")
+ ax.grid(axis="y", linestyle="--", alpha=0.5)
+ fig.savefig(figure_dir / "pso_v4_runtime.png", dpi=200, bbox_inches="tight")
+ plt.close(fig)
+
+ # 4. Rank Heatmap Plot (pso_v4_rank_heatmap.png)
+ if main_sums and datasets and methods:
+ fig, ax = plt.subplots(figsize=(8, 6))
+ rank_matrix = np.full((len(methods), len(datasets)), np.nan)
+
+ for i, m in enumerate(methods):
+ for j, ds in enumerate(datasets):
+ match = [s for s in main_sums if s["dataset"] == ds and s["method"] == m]
+ if match and "rank_acc" in match[0]:
+ rank_matrix[i, j] = match[0]["rank_acc"]
+
+ masked_matrix = np.ma.masked_invalid(rank_matrix)
+ n_methods = len(methods)
+ cmap = plt.get_cmap("YlGnBu_r", n_methods)
+ norm = matplotlib.colors.BoundaryNorm(np.arange(0.5, n_methods + 1.5, 1.0), n_methods)
+
+ cax = ax.matshow(
+ masked_matrix,
+ cmap=cmap,
+ norm=norm,
+ )
+ cb = fig.colorbar(cax, ticks=np.arange(1, n_methods + 1), label="Rank (1 = Best Evaluation Accuracy)")
+ cb.ax.set_yticklabels([str(r) for r in range(1, n_methods + 1)])
+
+ ax.set_xticks(np.arange(len(datasets)))
+ ax.set_yticks(np.arange(len(methods)))
+ ax.set_xticklabels(datasets)
+ ax.set_yticklabels(methods)
+
+ ax.set_xticks(np.arange(len(datasets)) - 0.5, minor=True)
+ ax.set_yticks(np.arange(len(methods)) - 0.5, minor=True)
+ ax.grid(which="minor", color="white", linestyle="-", linewidth=2)
+ ax.tick_params(which="minor", size=0)
+
+ for i in range(len(methods)):
+ for j in range(len(datasets)):
+ val = rank_matrix[i, j]
+ if not np.isnan(val):
+ rgba = cmap(norm(val))
+ luminance = (
+ 0.2126 * rgba[0] + 0.7152 * rgba[1] + 0.0722 * rgba[2]
+ )
+ ax.text(
+ j,
+ i,
+ str(int(val)),
+ ha="center",
+ va="center",
+ color="black" if luminance > 0.55 else "white",
+ fontweight="bold",
+ )
+ ax.tick_params(
+ bottom=False,
+ labelbottom=False,
+ top=True,
+ labeltop=True,
+ )
+ ax.set_title(f"PSO Method Accuracy Ranks Across Workloads\n(mean ± 1 SD, n={n_seeds}; XOR=train, others=held-out)", pad=20)
+ fig.savefig(figure_dir / "pso_v4_rank_heatmap.png", dpi=200, bbox_inches="tight")
+ plt.close(fig)
+
+ # 5. MNIST Ablation Plot (pso_v4_mnist_ablation.png)
+ ablation_sums = summaries.get("ablation", [])
+ if ablation_sums:
+ n_abl_seeds = max([s.get("n_runs", 5) for s in ablation_sums]) if ablation_sums else 5
+
+ fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 9), sharex=True)
+
+ by_profile = {s["profile"]: s for s in ablation_sums}
+ sorted_ablation = [
+ by_profile[name] for name in ABLATION_PROFILES if name in by_profile
+ ]
+ profiles = [s["profile"] for s in sorted_ablation]
+ acc_means = [s["eval_acc"]["mean"] for s in sorted_ablation]
+ acc_errs = [s["eval_acc"]["std"] for s in sorted_ablation]
+ loss_means = [s["eval_loss"]["mean"] for s in sorted_ablation]
+ loss_errs = [s["eval_loss"]["std"] for s in sorted_ablation]
+
+ colors = []
+ hatches = []
+ display_labels = []
+
+ for p_name in profiles:
+ p_cfg = ABLATION_PROFILES.get(p_name, {})
+ if p_cfg.get("refinement") == "adam" or "adam" in p_name:
+ colors.append("#D55E00")
+ hatches.append("xx")
+ display_labels.append(f"{p_name}\n(gradient-based)")
+ elif p_cfg.get("method") == "adaptive_moment" or "adaptive_moment" in p_name:
+ colors.append("#CC79A7")
+ hatches.append("||")
+ display_labels.append(f"{p_name}\n(derivative-free)")
+ else:
+ colors.append("#0072B2")
+ hatches.append("//")
+ display_labels.append(f"{p_name}\n(derivative-free)")
+
+ x = np.arange(len(profiles))
+ for i in range(len(profiles)):
+ ax1.bar(
+ x[i],
+ acc_means[i],
+ yerr=acc_errs[i],
+ color=colors[i],
+ hatch=hatches[i],
+ edgecolor="black",
+ linewidth=0.8,
+ capsize=4,
+ )
+
+ ax1.set_ylabel("Held-Out Accuracy")
+ ax1.set_title(f"MNIST PCA32 Linear Ablation Study Profiles\n(mean ± 1 SD, n={n_abl_seeds}; Held-Out Evaluation)")
+ ax1.grid(axis="y", linestyle="--", alpha=0.5)
+
+ legend_patches = [
+ Patch(facecolor="#0072B2", hatch="//", edgecolor="black", label="Derivative-Free (Standard PSO)"),
+ Patch(facecolor="#CC79A7", hatch="||", edgecolor="black", label="Derivative-Free (Adaptive Moment)"),
+ Patch(facecolor="#D55E00", hatch="xx", edgecolor="black", label="Gradient-Based (Adam Refinement)"),
+ ]
+ ax1.legend(handles=legend_patches, loc="upper left")
+
+ lower_loss_errs = [min(s, max(0.0, m - 1e-6)) for m, s in zip(loss_means, loss_errs)]
+ upper_loss_errs = loss_errs
+
+ for i in range(len(profiles)):
+ yerr_single = [[lower_loss_errs[i]], [upper_loss_errs[i]]]
+ ax2.bar(
+ x[i],
+ loss_means[i],
+ yerr=yerr_single,
+ color=colors[i],
+ hatch=hatches[i],
+ edgecolor="black",
+ linewidth=0.8,
+ capsize=4,
+ )
+
+ ax2.set_yscale("log")
+ ax2.set_ylabel("Held-Out Loss (log scale)")
+ ax2.set_xticks(x)
+ ax2.set_xticklabels(display_labels, rotation=45, ha="right")
+ ax2.grid(axis="y", linestyle="--", alpha=0.5)
+
+ fig.savefig(figure_dir / "pso_v4_mnist_ablation.png", dpi=200, bbox_inches="tight")
+ plt.close(fig)
+
+def run_benchmark(
+ quick: bool = False,
+ overwrite: bool = False,
+ skip_main: bool = False,
+ skip_ablation: bool = False,
+ dataset_filter: Optional[List[str]] = None,
+ method_filter: Optional[List[str]] = None,
+ seed_filter: Optional[List[int]] = None,
+ device_name: Optional[str] = None,
+ output_json: Path = Path("benchmark_results/pso_v4_benchmark.json"),
+ main_csv: Path = Path("benchmark_results/pso_v4_main_benchmark.csv"),
+ ablation_csv: Path = Path("benchmark_results/pso_v4_ablation_benchmark.csv"),
+ figure_dir: Path = Path("history_plt"),
+):
+ device = resolve_execution_device(device_name)
+ print(f"Executing benchmark suite on device: {device}")
+
+ hw_provenance = get_hardware_provenance(device)
+
+ # Load existing JSON if available and not overwrite
+ existing_data: Dict[str, Any] = {}
+ completed_runs: Dict[str, Dict[str, Any]] = {}
+ if output_json.exists() and not overwrite:
+ try:
+ with open(output_json, "r", encoding="utf-8") as f:
+ existing_data = json.load(f)
+ if existing_data.get("benchmark_protocol_version") == BENCHMARK_PROTOCOL_VERSION:
+ for r in existing_data.get("runs", []):
+ if r.get("completed") and "run_id" in r:
+ completed_runs[r["run_id"]] = r
+ print(f"Loaded {len(completed_runs)} existing completed runs from {output_json}")
+ else:
+ print(
+ f"Existing JSON protocol version ({existing_data.get('benchmark_protocol_version')}) "
+ f"differs from {BENCHMARK_PROTOCOL_VERSION}. Starting fresh."
+ )
+ except Exception as e:
+ print(f"Warning: Failed to load existing JSON ({e}). Starting fresh.")
+
+ all_runs: List[Dict[str, Any]] = list(completed_runs.values())
+
+ # Build targets
+ main_datasets = list(WORKLOADS.keys())
+ if dataset_filter:
+ ds_filter_upper = [d.upper() for d in dataset_filter]
+ main_datasets = [d for d in main_datasets if d.upper() in ds_filter_upper]
+
+ main_methods = list(MAIN_METHODS)
+ if method_filter:
+ m_filter_lower = [m.lower() for m in method_filter]
+ main_methods = [m for m in main_methods if m.lower() in m_filter_lower]
+
+ main_seeds = [41, 42, 43, 44, 45]
+ if seed_filter:
+ main_seeds = list(seed_filter)
+ if quick:
+ main_seeds = main_seeds[:1]
+
+ ablation_profiles = dict(ABLATION_PROFILES)
+ if method_filter:
+ p_filter_lower = [m.lower() for m in method_filter]
+ ablation_profiles = {
+ k: v for k, v in ablation_profiles.items() if k.lower() in p_filter_lower or v["method"].lower() in p_filter_lower
+ }
+
+ ablation_seeds = [46, 47, 48, 49, 50]
+ if seed_filter:
+ ablation_seeds = list(seed_filter)
+ if quick:
+ ablation_seeds = ablation_seeds[:1]
+
+ # --- 1. Main Benchmark Runs ---
+ if not skip_main:
+ print("\n=== Running Main Benchmark Suite ===")
+ for ds_name in main_datasets:
+ wl = WORKLOADS[ds_name]
+ task = wl["task"]
+ n_particles = 2 if quick else wl["n_particles"]
+ epochs = 2 if quick else wl["epochs"]
+ evaluation = wl["evaluation"]
+ fitness_size = (50 if quick else wl["fitness_size"]) if evaluation == "fixed_subset" else None
+ batch_size = (25 if quick else wl["batch_size"]) if evaluation == "fixed_subset" else None
+
+ for method in main_methods:
+ vel_limit = None if method == "bare_bones" else 0.1
+ for seed in main_seeds:
+ config_payload = {
+ "benchmark_protocol_version": BENCHMARK_PROTOCOL_VERSION,
+ "quick": quick,
+ "device": str(device),
+ "pso_version": pso_version,
+ "dataset": ds_name,
+ "type": "main",
+ "method": method,
+ "profile": method,
+ "seed": seed,
+ "n_particles": n_particles,
+ "epochs": epochs,
+ "evaluation": evaluation,
+ "fitness_size": fitness_size,
+ "batch_size": batch_size,
+ "particle_min": wl["particle_min"],
+ "particle_max": wl["particle_max"],
+ "initial_position_noise": wl["initial_position_noise"],
+ "renewal": wl["renewal"],
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": 0,
+ }
+ fp_bytes = json.dumps(config_payload, sort_keys=True, default=str).encode("utf-8")
+ config_fp = hashlib.sha256(fp_bytes).hexdigest()[:12]
+ run_id = f"main_{ds_name}_{method}_seed{seed}_{config_fp}"
+
+ if run_id in completed_runs and not overwrite:
+ print(f"Skipping completed run: {run_id}")
+ continue
+
+ print(f"Running {run_id}...")
+
+ # Data loading cached once per dataset+seed
+ x_train, x_test, y_train, y_test = get_cached_dataset(ds_name, seed=seed)
+ data_fp = compute_data_fingerprint(x_train, x_test, y_train, y_test)
+
+ # --- Untimed Warmup Phase ---
+ warmup_model = wl["model_factory"](seed=seed)
+ warmup_loss = wl["loss_fn"]()
+ warmup_opt = Optimizer(
+ model=warmup_model,
+ loss=warmup_loss,
+ task=task,
+ method=method,
+ initialization="model_noise",
+ evaluation=evaluation,
+ convergence="none",
+ refinement="none",
+ n_particles=n_particles,
+ velocity_limit_ratio=vel_limit,
+ boundary_strategy="reflect",
+ particle_min=wl["particle_min"],
+ particle_max=wl["particle_max"],
+ initial_position_noise=wl["initial_position_noise"],
+ seed=seed,
+ device=device,
+ fitness_size=fitness_size,
+ )
+ warmup_opt.fit(
+ x_train,
+ y_train,
+ epochs=2,
+ batch_size=batch_size,
+ fitness_size=fitness_size,
+ renewal=wl["renewal"],
+ )
+ sync_device(device)
+ del warmup_opt, warmup_model, warmup_loss
+
+ # --- Timed Model & Optimizer Construction ---
+ model = wl["model_factory"](seed=seed)
+ model_fp = compute_model_fingerprint(model)
+ loss_inst = wl["loss_fn"]()
+ model_params = sum(p.numel() for p in model.parameters())
+
+ opt = Optimizer(
+ model=model,
+ loss=loss_inst,
+ task=task,
+ method=method,
+ initialization="model_noise",
+ evaluation=evaluation,
+ convergence="none",
+ refinement="none",
+ n_particles=n_particles,
+ velocity_limit_ratio=vel_limit,
+ boundary_strategy="reflect",
+ particle_min=wl["particle_min"],
+ particle_max=wl["particle_max"],
+ initial_position_noise=wl["initial_position_noise"],
+ seed=seed,
+ device=device,
+ fitness_size=fitness_size,
+ )
+
+ resolved_plugins = extract_plugin_metadata(opt)
+
+ # Fit-only timing scope
+ sync_device(device)
+ t0 = time.perf_counter()
+
+ train_score = opt.fit(
+ x_train,
+ y_train,
+ epochs=epochs,
+ batch_size=batch_size,
+ fitness_size=fitness_size,
+ renewal=wl["renewal"],
+ )
+
+ sync_device(device)
+ t1 = time.perf_counter()
+ runtime_sec = t1 - t0
+
+ # Score evaluation
+ score_source = "train" if not wl["held_out"] else "held_out"
+ if wl["held_out"]:
+ eval_score = opt.evaluate(x_test, y_test, batch_size=batch_size)
+ else:
+ eval_score = opt.evaluate(x_train, y_train, batch_size=batch_size)
+
+ run_record = {
+ "run_id": run_id,
+ "benchmark_protocol_version": BENCHMARK_PROTOCOL_VERSION,
+ "config_fingerprint": config_fp,
+ "data_fingerprint": data_fp,
+ "initial_model_fingerprint": model_fp,
+ "type": "main",
+ "dataset": ds_name,
+ "method": method,
+ "profile": method,
+ "seed": seed,
+ "n_particles": n_particles,
+ "epochs": epochs,
+ "score_source": score_source,
+ "model_param_count": model_params,
+ "train_data_size": len(x_train),
+ "eval_data_size": len(x_test) if wl["held_out"] else len(x_train),
+ "configured_pca_choice": wl["pca_config"],
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": 0,
+ "untimed": True,
+ },
+ "config": config_payload,
+ "resolved_plugins": resolved_plugins,
+ "hardware_provenance": hw_provenance,
+ "device": str(device),
+ "pso_version": pso_version,
+ "torch_version": torch.__version__,
+ "train_metrics": {
+ "loss": float(train_score[0]),
+ "accuracy": float(train_score[1]),
+ "mse": float(train_score[2]),
+ },
+ "eval_metrics": {
+ "loss": float(eval_score[0]),
+ "accuracy": float(eval_score[1]),
+ "mse": float(eval_score[2]),
+ },
+ "runtime_seconds": float(runtime_sec),
+ "completed": True,
+ "error": None,
+ }
+
+ all_runs.append(run_record)
+ completed_runs[run_id] = run_record
+
+ sums = compute_summaries_and_ranks(all_runs)
+ save_json_atomic(
+ {
+ "benchmark_protocol_version": BENCHMARK_PROTOCOL_VERSION,
+ "version": pso_version,
+ "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+ "environment": hw_provenance,
+ "runs": all_runs,
+ "summaries": sums,
+ },
+ output_json,
+ )
+
+ # --- 2. Ablation Suite Runs ---
+ if not skip_ablation and (dataset_filter is None or any(d.upper() == "MNIST" for d in dataset_filter)):
+ print("\n=== Running MNIST Ablation Benchmark Suite ===")
+ wl = WORKLOADS["MNIST"]
+ task = wl["task"]
+
+ for p_name, p_cfg in ablation_profiles.items():
+ method = p_cfg["method"]
+ evaluation = p_cfg["evaluation"]
+ n_particles = 2 if quick else wl["n_particles"]
+ epochs = 2 if quick else wl["epochs"]
+ fitness_size = (50 if quick else p_cfg["fitness_size"]) if evaluation == "fixed_subset" else None
+ batch_size = (25 if quick else p_cfg["batch_size"]) if evaluation == "fixed_subset" else None
+ refinement_epochs = min(2, p_cfg.get("refinement_epochs", 0)) if quick else p_cfg.get("refinement_epochs", 0)
+ refinement_lr = p_cfg.get("refinement_lr", 0.001)
+ is_adam = (p_cfg.get("refinement") == "adam")
+ warmup_refinement_epochs = 1 if is_adam else 0
+
+ for seed in ablation_seeds:
+ config_payload = {
+ "benchmark_protocol_version": BENCHMARK_PROTOCOL_VERSION,
+ "quick": quick,
+ "device": str(device),
+ "pso_version": pso_version,
+ "dataset": "MNIST",
+ "type": "ablation",
+ "method": method,
+ "profile": p_name,
+ "seed": seed,
+ "n_particles": n_particles,
+ "epochs": epochs,
+ "evaluation": evaluation,
+ "fitness_size": fitness_size,
+ "batch_size": batch_size,
+ "particle_min": wl["particle_min"],
+ "particle_max": wl["particle_max"],
+ "initial_position_noise": wl["initial_position_noise"],
+ "renewal": wl["renewal"],
+ "c0": p_cfg.get("c0"),
+ "c1": p_cfg.get("c1"),
+ "w_min": p_cfg.get("w_min"),
+ "w_max": p_cfg.get("w_max"),
+ "velocity_limit_ratio": p_cfg.get("velocity_limit_ratio"),
+ "mutation_swarm": p_cfg.get("mutation_swarm", 0.0),
+ "initialization": p_cfg["initialization"],
+ "convergence": p_cfg["convergence"],
+ "refinement": p_cfg["refinement"],
+ "refinement_epochs": refinement_epochs,
+ "refinement_lr": refinement_lr,
+ "moment_blend": p_cfg.get("moment_blend"),
+ "warmup_pso_epochs": 2,
+ "warmup_refinement_epochs": warmup_refinement_epochs,
+ }
+ fp_bytes = json.dumps(config_payload, sort_keys=True, default=str).encode("utf-8")
+ config_fp = hashlib.sha256(fp_bytes).hexdigest()[:12]
+ run_id = f"ablation_MNIST_{p_name}_seed{seed}_{config_fp}"
+
+ if run_id in completed_runs and not overwrite:
+ print(f"Skipping completed run: {run_id}")
+ continue
+
+ print(f"Running {run_id}...")
+
+ x_train, x_test, y_train, y_test = get_cached_dataset("MNIST", seed=seed)
+ data_fp = compute_data_fingerprint(x_train, x_test, y_train, y_test)
+
+ # --- Untimed Warmup Phase ---
+ warmup_model = wl["model_factory"](seed=seed)
+ warmup_loss = wl["loss_fn"]()
+ warmup_opt_kwargs = {
+ "model": warmup_model,
+ "loss": warmup_loss,
+ "task": task,
+ "method": method,
+ "initialization": p_cfg["initialization"],
+ "evaluation": evaluation,
+ "convergence": p_cfg["convergence"],
+ "refinement": p_cfg["refinement"],
+ "n_particles": n_particles,
+ "c0": p_cfg.get("c0"),
+ "c1": p_cfg.get("c1"),
+ "w_min": p_cfg.get("w_min"),
+ "w_max": p_cfg.get("w_max"),
+ "velocity_limit_ratio": p_cfg.get("velocity_limit_ratio"),
+ "mutation_swarm": p_cfg.get("mutation_swarm", 0.0),
+ "boundary_strategy": "reflect",
+ "particle_min": wl["particle_min"],
+ "particle_max": wl["particle_max"],
+ "initial_position_noise": wl["initial_position_noise"],
+ "seed": seed,
+ "device": device,
+ "fitness_size": fitness_size,
+ "convergence_patience": p_cfg.get("convergence_patience", 10),
+ "convergence_min_delta": p_cfg.get("convergence_min_delta", 0.0001),
+ "refinement_epochs": warmup_refinement_epochs,
+ "refinement_lr": refinement_lr,
+ "moment_blend": p_cfg.get("moment_blend"),
+ }
+ warmup_opt = Optimizer(**warmup_opt_kwargs)
+ warmup_opt.fit(
+ x_train,
+ y_train,
+ epochs=2,
+ batch_size=batch_size,
+ fitness_size=fitness_size,
+ renewal=wl["renewal"],
+ refinement_epochs=warmup_refinement_epochs,
+ refinement_lr=refinement_lr,
+ )
+ sync_device(device)
+ del warmup_opt, warmup_model, warmup_loss
+
+ # --- Timed Model & Optimizer Construction ---
+ model = wl["model_factory"](seed=seed)
+ model_fp = compute_model_fingerprint(model)
+ loss_inst = wl["loss_fn"]()
+ model_params = sum(p.numel() for p in model.parameters())
+
+ opt_kwargs = {
+ "model": model,
+ "loss": loss_inst,
+ "task": task,
+ "method": method,
+ "initialization": p_cfg["initialization"],
+ "evaluation": evaluation,
+ "convergence": p_cfg["convergence"],
+ "refinement": p_cfg["refinement"],
+ "n_particles": n_particles,
+ "c0": p_cfg.get("c0"),
+ "c1": p_cfg.get("c1"),
+ "w_min": p_cfg.get("w_min"),
+ "w_max": p_cfg.get("w_max"),
+ "velocity_limit_ratio": p_cfg.get("velocity_limit_ratio"),
+ "mutation_swarm": p_cfg.get("mutation_swarm", 0.0),
+ "boundary_strategy": "reflect",
+ "particle_min": wl["particle_min"],
+ "particle_max": wl["particle_max"],
+ "initial_position_noise": wl["initial_position_noise"],
+ "seed": seed,
+ "device": device,
+ "fitness_size": fitness_size,
+ "convergence_patience": p_cfg.get("convergence_patience", 10),
+ "convergence_min_delta": p_cfg.get("convergence_min_delta", 0.0001),
+ "refinement_epochs": refinement_epochs,
+ "refinement_lr": refinement_lr,
+ "moment_blend": p_cfg.get("moment_blend"),
+ }
+
+ opt = Optimizer(**opt_kwargs)
+ resolved_plugins = extract_plugin_metadata(opt)
+
+ sync_device(device)
+ t0 = time.perf_counter()
+
+ train_score = opt.fit(
+ x_train,
+ y_train,
+ epochs=epochs,
+ batch_size=batch_size,
+ fitness_size=fitness_size,
+ renewal=wl["renewal"],
+ refinement_epochs=refinement_epochs,
+ refinement_lr=refinement_lr,
+ )
+
+ sync_device(device)
+ t1 = time.perf_counter()
+ runtime_sec = t1 - t0
+
+ eval_score = opt.evaluate(x_test, y_test, batch_size=batch_size)
+
+ run_record = {
+ "run_id": run_id,
+ "benchmark_protocol_version": BENCHMARK_PROTOCOL_VERSION,
+ "config_fingerprint": config_fp,
+ "data_fingerprint": data_fp,
+ "initial_model_fingerprint": model_fp,
+ "type": "ablation",
+ "dataset": "MNIST",
+ "method": method,
+ "profile": p_name,
+ "seed": seed,
+ "n_particles": n_particles,
+ "epochs": epochs,
+ "score_source": "held_out",
+ "model_param_count": model_params,
+ "train_data_size": len(x_train),
+ "eval_data_size": len(x_test),
+ "configured_pca_choice": wl["pca_config"],
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_protocol": {
+ "pso_epochs": 2,
+ "refinement_epochs": warmup_refinement_epochs,
+ "untimed": True,
+ },
+ "config": config_payload,
+ "resolved_plugins": resolved_plugins,
+ "hardware_provenance": hw_provenance,
+ "device": str(device),
+ "pso_version": pso_version,
+ "torch_version": torch.__version__,
+ "train_metrics": {
+ "loss": float(train_score[0]),
+ "accuracy": float(train_score[1]),
+ "mse": float(train_score[2]),
+ },
+ "eval_metrics": {
+ "loss": float(eval_score[0]),
+ "accuracy": float(eval_score[1]),
+ "mse": float(eval_score[2]),
+ },
+ "runtime_seconds": float(runtime_sec),
+ "completed": True,
+ "error": None,
+ }
+
+ all_runs.append(run_record)
+ completed_runs[run_id] = run_record
+
+ sums = compute_summaries_and_ranks(all_runs)
+ save_json_atomic(
+ {
+ "benchmark_protocol_version": BENCHMARK_PROTOCOL_VERSION,
+ "version": pso_version,
+ "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+ "environment": hw_provenance,
+ "runs": all_runs,
+ "summaries": sums,
+ },
+ output_json,
+ )
+
+ # Compute final summaries, write CSVs, render PNG charts
+ final_summaries = compute_summaries_and_ranks(all_runs)
+ save_json_atomic(
+ {
+ "benchmark_protocol_version": BENCHMARK_PROTOCOL_VERSION,
+ "version": pso_version,
+ "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+ "environment": hw_provenance,
+ "runs": all_runs,
+ "summaries": final_summaries,
+ },
+ output_json,
+ )
+
+ print("\nWriting CSV reports...")
+ write_csv_reports(final_summaries, main_csv, ablation_csv)
+
+ print("Rendering Matplotlib figure charts...")
+ render_plots(final_summaries, figure_dir)
+
+ print(f"\nBenchmark suite completed successfully!")
+ print(f"- JSON: {output_json}")
+ print(f"- Main CSV: {main_csv}")
+ print(f"- Ablation CSV: {ablation_csv}")
+ print(f"- Figures in: {figure_dir}")
+
+
+def main():
+ parser = argparse.ArgumentParser(
+ description="PSO v4 Deterministic Multi-Seed Benchmark Runner & Analysis Suite",
+ formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+ )
+ parser.add_argument("--quick", action="store_true", help="Run tiny subset for rapid testing")
+ parser.add_argument("--overwrite", action="store_true", help="Overwrite cached JSON run results")
+ parser.add_argument("--skip-main", action="store_true", help="Skip main benchmark execution")
+ parser.add_argument("--skip-ablation", action="store_true", help="Skip ablation benchmark execution")
+ parser.add_argument("--datasets", type=str, help="Comma-separated dataset filter (e.g. XOR,Iris,MNIST)")
+ parser.add_argument("--methods", type=str, help="Comma-separated method/profile filter (e.g. original,inertia)")
+ parser.add_argument("--seeds", type=str, help="Comma-separated seeds or range (e.g. 41,42 or 41-45)")
+ parser.add_argument("--device", type=str, help="Target execution device (cpu, cuda, mps)")
+ parser.add_argument(
+ "--output",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_benchmark.json"),
+ help="Output JSON path",
+ )
+ parser.add_argument(
+ "--main-csv",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_main_benchmark.csv"),
+ help="Main benchmark CSV output path",
+ )
+ parser.add_argument(
+ "--ablation-csv",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_ablation_benchmark.csv"),
+ help="Ablation CSV output path",
+ )
+ parser.add_argument(
+ "--figure-dir",
+ type=Path,
+ default=Path("history_plt"),
+ help="Figure export directory for PNGs",
+ )
+
+ args = parser.parse_args()
+
+ ds_filter = [d.strip() for d in args.datasets.split(",")] if args.datasets else None
+ m_filter = [m.strip() for m in args.methods.split(",")] if args.methods else None
+
+ seed_filter = None
+ if args.seeds:
+ seed_filter = []
+ for s_part in args.seeds.split(","):
+ s_part = s_part.strip()
+ if "-" in s_part:
+ start_s, end_s = s_part.split("-", 1)
+ seed_filter.extend(list(range(int(start_s), int(end_s) + 1)))
+ else:
+ seed_filter.append(int(s_part))
+
+ run_benchmark(
+ quick=args.quick,
+ overwrite=args.overwrite,
+ skip_main=args.skip_main,
+ skip_ablation=args.skip_ablation,
+ dataset_filter=ds_filter,
+ method_filter=m_filter,
+ seed_filter=seed_filter,
+ device_name=args.device,
+ output_json=args.output,
+ main_csv=args.main_csv,
+ ablation_csv=args.ablation_csv,
+ figure_dir=args.figure_dir,
+ )
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/cli.py b/test/cli.py
new file mode 100644
index 0000000..721cda7
--- /dev/null
+++ b/test/cli.py
@@ -0,0 +1,490 @@
+"""
+Command-Line Interface Helpers for PSO Experiments.
+
+Provides standard argparse argument groups and helper functions for PSO stage selectors
+(method, initialization, evaluation, convergence, refinement) and common execution parameters.
+"""
+
+import argparse
+from typing import Any
+
+# Supported stage plugin selector options
+STAGE_SELECTORS: dict[str, list[str]] = {
+ "method": [
+ "original",
+ "inertia",
+ "constriction",
+ "fips",
+ "clpso",
+ "bare_bones",
+ "adaptive_moment",
+ ],
+ "initialization": ["model_noise", "uniform"],
+ "evaluation": ["full", "fixed_subset"],
+ "convergence": ["none", "particle_reset", "early_stopping"],
+ "refinement": ["none", "adam"],
+}
+
+
+def add_stage_selector_args(
+ parser: argparse.ArgumentParser, defaults: dict[str, Any] | None = None
+) -> argparse.ArgumentParser:
+ """Adds the 5 explicit stage selector arguments to an argparse parser."""
+ defaults = defaults or {}
+
+ parser.add_argument(
+ "--method",
+ type=str,
+ choices=STAGE_SELECTORS["method"],
+ default=defaults.get("method", "original"),
+ help="PSO movement stage method (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--initialization",
+ type=str,
+ choices=STAGE_SELECTORS["initialization"],
+ default=defaults.get("initialization", "model_noise"),
+ help="PSO particle initialization stage (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--evaluation",
+ type=str,
+ choices=STAGE_SELECTORS["evaluation"],
+ default=defaults.get("evaluation", "full"),
+ help="PSO objective evaluation stage (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--convergence",
+ type=str,
+ choices=STAGE_SELECTORS["convergence"],
+ default=defaults.get("convergence", "none"),
+ help="PSO convergence behavior stage (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--refinement",
+ type=str,
+ choices=STAGE_SELECTORS["refinement"],
+ default=defaults.get("refinement", "none"),
+ help="PSO post-search refinement stage (default: %(default)s)",
+ )
+ return parser
+
+
+def add_pso_args(
+ parser: argparse.ArgumentParser, defaults: dict[str, Any] | None = None
+) -> argparse.ArgumentParser:
+ """Adds stage selectors and common PSO hyperparameter arguments to an argparse parser."""
+ defaults = defaults or {}
+
+ # Add 5 stage selectors
+ add_stage_selector_args(parser, defaults)
+
+ # Core execution and hyperparameter options
+ parser.add_argument(
+ "--seed",
+ type=int,
+ default=defaults.get("seed", 42),
+ help="Random seed for reproducibility (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--device",
+ type=str,
+ default=defaults.get("device", None),
+ help="Execution target device (cpu, cuda, mps) (default: auto)",
+ )
+ parser.add_argument(
+ "--n-particles",
+ "--particles",
+ dest="n_particles",
+ type=int,
+ default=defaults.get("n_particles", 30),
+ help="Number of swarm particles (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--epochs",
+ type=int,
+ default=defaults.get("epochs", 80),
+ help="Number of PSO optimization epochs (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--batch-size",
+ "--batch",
+ dest="batch_size",
+ type=int,
+ default=defaults.get("batch_size", None),
+ help="Batch size for objective evaluation (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--fitness-size",
+ type=int,
+ default=defaults.get("fitness_size", None),
+ help="Fixed subset sample count (required when evaluation='fixed_subset')",
+ )
+ parser.add_argument(
+ "--refinement-epochs",
+ type=int,
+ default=defaults.get("refinement_epochs", 0),
+ help="Refinement epoch count (required when refinement='adam')",
+ )
+ parser.add_argument(
+ "--refinement-lr",
+ type=float,
+ default=defaults.get("refinement_lr", 0.001),
+ help="Refinement learning rate for Adam optimizer (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--renewal",
+ type=str,
+ choices=["acc", "loss", "mse"],
+ default=defaults.get("renewal", "loss"),
+ help="Primary metric for global best selection (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--output-dir",
+ type=str,
+ default=defaults.get("output_dir", None),
+ help="Directory to save model checkpoints and logs",
+ )
+
+ # Optional coefficient overrides
+ parser.add_argument(
+ "--c0",
+ type=float,
+ default=defaults.get("c0", None),
+ help="Cognitive acceleration coefficient override",
+ )
+ parser.add_argument(
+ "--c1",
+ type=float,
+ default=defaults.get("c1", None),
+ help="Social acceleration coefficient override",
+ )
+ parser.add_argument(
+ "--w-min",
+ dest="w_min",
+ type=float,
+ default=defaults.get("w_min", None),
+ help="Minimum inertia weight override",
+ )
+ parser.add_argument(
+ "--w-max",
+ dest="w_max",
+ type=float,
+ default=defaults.get("w_max", None),
+ help="Maximum inertia weight override",
+ )
+ parser.add_argument(
+ "--negative-swarm",
+ type=float,
+ default=defaults.get("negative_swarm", 0.0),
+ help="Negative swarm velocity coefficient (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--mutation-swarm",
+ type=float,
+ default=defaults.get("mutation_swarm", 0.0),
+ help="Swarm mutation probability (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--particle-min",
+ type=float,
+ default=defaults.get("particle_min", None),
+ help="Lower bound for particle position clamping",
+ )
+ parser.add_argument(
+ "--particle-max",
+ type=float,
+ default=defaults.get("particle_max", None),
+ help="Upper bound for particle position clamping",
+ )
+ parser.add_argument(
+ "--velocity-limit-ratio",
+ type=float,
+ default=defaults.get("velocity_limit_ratio", None),
+ help="Maximum velocity limit ratio relative to search domain",
+ )
+ parser.add_argument(
+ "--boundary-strategy",
+ type=str,
+ choices=["clip", "reflect"],
+ default=defaults.get("boundary_strategy", "clip"),
+ help="Position boundary handling strategy (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--initial-position-noise",
+ type=float,
+ default=defaults.get("initial_position_noise", 0.05),
+ help="Initial position noise scale (default: %(default)s)",
+ )
+ # Convergence stage options
+ parser.add_argument(
+ "--convergence-patience",
+ dest="convergence_patience",
+ type=int,
+ default=defaults.get("convergence_patience", 10),
+ help="Convergence reset/early stopping patience epochs (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--convergence-min-delta",
+ dest="convergence_min_delta",
+ type=float,
+ default=defaults.get("convergence_min_delta", 0.0001),
+ help="Minimum improvement delta for convergence (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--convergence-monitor",
+ dest="convergence_monitor",
+ type=str,
+ choices=["loss", "acc", "accuracy", "mse"],
+ default=defaults.get("convergence_monitor", "loss"),
+ help="Metric monitored for convergence (default: %(default)s)",
+ )
+
+ # Adaptive moment options
+ parser.add_argument(
+ "--moment-blend",
+ dest="moment_blend",
+ type=float,
+ default=defaults.get("moment_blend", None),
+ help="Adaptive moment blend factor (default: 0.25 when method='adaptive_moment', else 0.0)",
+ )
+ parser.add_argument(
+ "--moment-beta1",
+ dest="moment_beta1",
+ type=float,
+ default=defaults.get("moment_beta1", None),
+ help="Adaptive moment beta1 parameter (default: 0.9 when method='adaptive_moment')",
+ )
+ parser.add_argument(
+ "--moment-beta2",
+ dest="moment_beta2",
+ type=float,
+ default=defaults.get("moment_beta2", None),
+ help="Adaptive moment beta2 parameter (default: 0.999 when method='adaptive_moment')",
+ )
+ parser.add_argument(
+ "--moment-step-size",
+ dest="moment_step_size",
+ type=float,
+ default=defaults.get("moment_step_size", None),
+ help="Adaptive moment step size (default: 1.0 when method='adaptive_moment')",
+ )
+ parser.add_argument(
+ "--moment-epsilon",
+ dest="moment_epsilon",
+ type=float,
+ default=defaults.get("moment_epsilon", None),
+ help="Adaptive moment epsilon parameter (default: 1e-8 when method='adaptive_moment')",
+ )
+
+ # Repeatable method options
+ parser.add_argument(
+ "--method-option",
+ dest="method_options",
+ action="append",
+ metavar="KEY=VALUE",
+ help="Additional key=value option for movement method (repeatable)",
+ )
+ return parser
+
+
+def parse_method_options(options: list[str] | None) -> dict[str, Any]:
+ """Parses a list of 'KEY=VALUE' strings into a dictionary with typed values."""
+ res: dict[str, Any] = {}
+ if not options:
+ return res
+ for opt in options:
+ if "=" not in opt:
+ raise ValueError(f"Invalid --method-option format '{opt}', expected 'KEY=VALUE'")
+ key, val = opt.split("=", 1)
+ key = key.strip()
+ val = val.strip()
+ val_lower = val.lower()
+ if val_lower == "true":
+ parsed_val: Any = True
+ elif val_lower == "false":
+ parsed_val = False
+ else:
+ try:
+ parsed_val = int(val)
+ except ValueError:
+ try:
+ parsed_val = float(val)
+ except ValueError:
+ parsed_val = val
+ res[key] = parsed_val
+ return res
+
+
+def build_optimizer_kwargs(
+ args: argparse.Namespace,
+ *,
+ model: Any = None,
+ loss: Any = None,
+ task: str | None = None,
+ inertia_profile: dict[str, float] | None = None,
+ **extra_kwargs: Any,
+) -> dict[str, Any]:
+ """Builds Optimizer constructor keyword arguments from parsed CLI arguments.
+
+ Applies method-specific parameter compatibility rules, workload inertia profiles
+ (only when method='inertia'), repeatable method options (--method-option), and
+ adaptive moment flags (only when method='adaptive_moment').
+ """
+ method = getattr(args, "method", "original")
+ parsed_method_opts = parse_method_options(getattr(args, "method_options", None))
+
+ if method == "inertia":
+ profile = inertia_profile or {}
+ c0 = (
+ parsed_method_opts["c0"]
+ if "c0" in parsed_method_opts
+ else (args.c0 if getattr(args, "c0", None) is not None else profile.get("c0"))
+ )
+ c1 = (
+ parsed_method_opts["c1"]
+ if "c1" in parsed_method_opts
+ else (args.c1 if getattr(args, "c1", None) is not None else profile.get("c1"))
+ )
+ w_min = (
+ parsed_method_opts["w_min"]
+ if "w_min" in parsed_method_opts
+ else (args.w_min if getattr(args, "w_min", None) is not None else profile.get("w_min"))
+ )
+ w_max = (
+ parsed_method_opts["w_max"]
+ if "w_max" in parsed_method_opts
+ else (args.w_max if getattr(args, "w_max", None) is not None else profile.get("w_max"))
+ )
+ elif method in ("original", "constriction", "fips"):
+ c0 = (
+ parsed_method_opts["c0"]
+ if "c0" in parsed_method_opts
+ else getattr(args, "c0", None)
+ )
+ c1 = (
+ parsed_method_opts["c1"]
+ if "c1" in parsed_method_opts
+ else getattr(args, "c1", None)
+ )
+ w_min = None
+ w_max = None
+ elif method == "bare_bones":
+ c0 = None
+ c1 = None
+ w_min = None
+ w_max = None
+ else:
+ c0 = (
+ parsed_method_opts["c0"]
+ if "c0" in parsed_method_opts
+ else getattr(args, "c0", None)
+ )
+ c1 = (
+ parsed_method_opts["c1"]
+ if "c1" in parsed_method_opts
+ else getattr(args, "c1", None)
+ )
+ w_min = (
+ parsed_method_opts["w_min"]
+ if "w_min" in parsed_method_opts
+ else getattr(args, "w_min", None)
+ )
+ w_max = (
+ parsed_method_opts["w_max"]
+ if "w_max" in parsed_method_opts
+ else getattr(args, "w_max", None)
+ )
+
+ if method in ("fips", "clpso", "bare_bones"):
+ neg_swarm = 0.0
+ else:
+ neg_swarm = (
+ float(parsed_method_opts["negative_swarm"])
+ if "negative_swarm" in parsed_method_opts
+ else float(getattr(args, "negative_swarm", 0.0))
+ )
+
+ if method == "bare_bones":
+ mut_swarm = 0.0
+ else:
+ mut_swarm = (
+ float(parsed_method_opts["mutation_swarm"])
+ if "mutation_swarm" in parsed_method_opts
+ else float(getattr(args, "mutation_swarm", 0.0))
+ )
+
+ if method == "bare_bones":
+ vel_ratio = None
+ else:
+ vel_ratio = (
+ parsed_method_opts["velocity_limit_ratio"]
+ if "velocity_limit_ratio" in parsed_method_opts
+ else getattr(args, "velocity_limit_ratio", None)
+ )
+
+ fitness_size = (
+ getattr(args, "fitness_size", None)
+ if getattr(args, "evaluation", None) == "fixed_subset"
+ else None
+ )
+ refinement_epochs = (
+ getattr(args, "refinement_epochs", 0)
+ if getattr(args, "refinement", None) == "adam"
+ else 0
+ )
+
+ kwargs: dict[str, Any] = {
+ "model": model,
+ "loss": loss,
+ "task": task,
+ "method": method,
+ "initialization": getattr(args, "initialization", "model_noise"),
+ "evaluation": getattr(args, "evaluation", "full"),
+ "convergence": getattr(args, "convergence", "none"),
+ "refinement": getattr(args, "refinement", "none"),
+ "method_options": parsed_method_opts,
+ "n_particles": getattr(args, "n_particles", 30),
+ "c0": c0,
+ "c1": c1,
+ "w_min": w_min,
+ "w_max": w_max,
+ "negative_swarm": neg_swarm,
+ "mutation_swarm": mut_swarm,
+ "particle_min": getattr(args, "particle_min", None),
+ "particle_max": getattr(args, "particle_max", None),
+ "velocity_limit_ratio": vel_ratio,
+ "boundary_strategy": getattr(args, "boundary_strategy", "clip"),
+ "initial_position_noise": getattr(args, "initial_position_noise", 0.05),
+ "seed": getattr(args, "seed", None),
+ "device": getattr(args, "device", None),
+ "fitness_size": fitness_size,
+ "convergence_patience": getattr(args, "convergence_patience", 10),
+ "convergence_min_delta": getattr(args, "convergence_min_delta", 0.0001),
+ "convergence_monitor": getattr(args, "convergence_monitor", "loss"),
+ "refinement_epochs": refinement_epochs,
+ "refinement_lr": getattr(args, "refinement_lr", 0.001),
+ }
+
+ if method == "adaptive_moment":
+ if "moment_blend" in parsed_method_opts:
+ m_blend = float(parsed_method_opts["moment_blend"])
+ elif getattr(args, "moment_blend", None) is not None:
+ m_blend = float(getattr(args, "moment_blend"))
+ else:
+ m_blend = 0.25
+ kwargs["moment_blend"] = m_blend
+
+ for param_name in (
+ "moment_beta1",
+ "moment_beta2",
+ "moment_step_size",
+ "moment_epsilon",
+ ):
+ if param_name in parsed_method_opts:
+ kwargs[param_name] = float(parsed_method_opts[param_name])
+ elif getattr(args, param_name, None) is not None:
+ kwargs[param_name] = float(getattr(args, param_name))
+
+ kwargs.update(extra_kwargs)
+ return kwargs
diff --git a/test/compare_methods.py b/test/compare_methods.py
new file mode 100755
index 0000000..9c04cfd
--- /dev/null
+++ b/test/compare_methods.py
@@ -0,0 +1,427 @@
+#!/usr/bin/env python3
+"""
+PSO Stage Plugin Method Comparison Tool.
+
+Compares PSO movement methods (original, inertia, constriction, fips, clpso, bare_bones,
+adaptive_moment, local_best, quantum)
+across benchmark datasets (xor, iris, mnist) with reproducible model initialization, dataset splits,
+and clean console output & JSON result reporting.
+"""
+
+import argparse
+import json
+import sys
+import time
+from typing import Any
+
+import torch
+import torch.nn as nn
+from cli import add_pso_args, parse_method_options
+from pso import Optimizer
+from pso.plugins import available_plugins
+
+
+def print_available_methods():
+ """Prints available movement method plugins and metadata provenance."""
+ movement_plugins = available_plugins("movement")
+ print("Available PSO Movement Method Plugins:")
+ print("=" * 80)
+ for name, meta in movement_plugins.items():
+ print(f" Stage Key : {name}")
+ print(f" Title : {meta.title}")
+ print(f" Source (DOI) : {meta.source or 'N/A'}")
+ print(f" Fidelity : {meta.fidelity}")
+ print(f" Needs Grad : {meta.gradient_required}")
+ print("-" * 80)
+
+
+def get_xor_workload(seed: int):
+ """Builds identical XOR dataset and PyTorch model state for a given seed."""
+ torch.manual_seed(seed)
+ x_train = torch.tensor(
+ [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]], dtype=torch.float32
+ )
+ y_train = torch.tensor([[0.0], [1.0], [1.0], [0.0]], dtype=torch.float32)
+
+ model = nn.Sequential(
+ nn.Linear(2, 4),
+ nn.Tanh(),
+ nn.Linear(4, 1),
+ )
+ loss_fn = nn.BCEWithLogitsLoss()
+ return x_train, y_train, None, model, loss_fn, "binary"
+
+
+def get_iris_workload(seed: int):
+ """Builds identical Iris dataset and PyTorch model state for a given seed."""
+ from sklearn.datasets import load_iris
+ from sklearn.model_selection import train_test_split
+ from sklearn.preprocessing import StandardScaler
+
+ torch.manual_seed(seed)
+ iris = load_iris()
+ X = iris.data.astype("float32")
+ y = iris.target.astype("int64")
+
+ x_train, x_test, y_train, y_test = train_test_split(
+ X, y, test_size=0.2, shuffle=True, stratify=y, random_state=seed
+ )
+ scaler = StandardScaler()
+ x_train = scaler.fit_transform(x_train)
+ x_test = scaler.transform(x_test)
+
+ x_tr = torch.tensor(x_train, dtype=torch.float32)
+ y_tr = torch.tensor(y_train, dtype=torch.int64)
+ x_te = torch.tensor(x_test, dtype=torch.float32)
+ y_te = torch.tensor(y_test, dtype=torch.int64)
+
+ model = nn.Sequential(
+ nn.Linear(4, 10),
+ nn.ReLU(),
+ nn.Linear(10, 10),
+ nn.ReLU(),
+ nn.Linear(10, 3),
+ )
+ loss_fn = nn.CrossEntropyLoss()
+ return x_tr, y_tr, (x_te, y_te), model, loss_fn, "multiclass"
+
+
+def get_mnist_workload(seed: int):
+ """Builds identical PCA32 MNIST dataset and PyTorch model state for a given seed."""
+ from sklearn.decomposition import PCA
+ from torchvision.datasets import MNIST
+
+ torch.manual_seed(seed)
+ train_ds = MNIST(root="./data", train=True, download=True)
+ test_ds = MNIST(root="./data", train=False, download=True)
+
+ x_tr_raw = (train_ds.data[:3000].float() / 255.0).reshape(3000, -1).numpy()
+ y_tr = train_ds.targets[:3000].long()
+ x_te_raw = (test_ds.data[:1000].float() / 255.0).reshape(1000, -1).numpy()
+ y_te = test_ds.targets[:1000].long()
+
+ pca = PCA(n_components=32, whiten=True, random_state=seed)
+ x_tr_pca = pca.fit_transform(x_tr_raw)
+ x_te_pca = pca.transform(x_te_raw)
+
+ x_tr = torch.tensor(x_tr_pca, dtype=torch.float32)
+ x_te = torch.tensor(x_te_pca, dtype=torch.float32)
+
+ model = nn.Linear(32, 10)
+ loss_fn = nn.CrossEntropyLoss()
+ return x_tr, y_tr, (x_te, y_te), model, loss_fn, "multiclass"
+
+
+DATASET_LOADERS = {
+ "xor": get_xor_workload,
+ "iris": get_iris_workload,
+ "mnist": get_mnist_workload,
+}
+
+
+def main():
+ parser = argparse.ArgumentParser(
+ description="PSO Stage Plugin Method Comparison Surface"
+ )
+ parser.add_argument(
+ "--list-methods",
+ action="store_true",
+ help="List available movement methods and exit",
+ )
+ parser.add_argument(
+ "--dataset",
+ choices=["xor", "iris", "mnist"],
+ default="xor",
+ help="Target dataset workload (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--methods",
+ nargs="+",
+ default=["all"],
+ help="Movement method keys to evaluate or 'all' (default: all)",
+ )
+ parser.add_argument(
+ "--seeds",
+ type=int,
+ nargs="+",
+ default=[42],
+ help="Random seed list (default: 42)",
+ )
+ parser.add_argument(
+ "--json-path",
+ "--output-json",
+ "--json",
+ dest="json_path",
+ type=str,
+ default=None,
+ help="Optional JSON file path to save detailed evaluation metrics",
+ )
+
+ # Add standard stage selector and hyperparameter options
+ add_pso_args(parser, defaults={"n_particles": 20, "epochs": 30})
+ args = parser.parse_args()
+
+ if args.list_methods:
+ print_available_methods()
+ sys.exit(0)
+
+ # Determine movement methods to test
+ available_m_plugins = available_plugins("movement")
+ if "all" in args.methods or "ALL" in args.methods:
+ methods_to_test = list(available_m_plugins.keys())
+ else:
+ methods_to_test = []
+ for m in args.methods:
+ if m not in available_m_plugins:
+ raise ValueError(
+ f"Unknown movement method '{m}'. Available: {list(available_m_plugins.keys())}"
+ )
+ methods_to_test.append(m)
+
+ loader = DATASET_LOADERS[args.dataset]
+ eval_stage = args.evaluation
+ fitness_size = args.fitness_size if eval_stage == "fixed_subset" else None
+
+ if eval_stage == "fixed_subset" and fitness_size is None:
+ if args.dataset == "xor":
+ fitness_size = 4
+ elif args.dataset == "iris":
+ fitness_size = 100
+ elif args.dataset == "mnist":
+ fitness_size = 2000
+ refine_stage = args.refinement
+ refinement_epochs = args.refinement_epochs if refine_stage == "adam" else 0
+
+ results: list[dict[str, Any]] = []
+ parsed_method_opts = parse_method_options(args.method_options)
+ has_val = args.dataset != "xor"
+
+ print("=" * 80)
+ print(f"PSO Movement Method Comparison on '{args.dataset}' Dataset")
+ print(
+ f"Stages: initialization='{args.initialization}', evaluation='{eval_stage}', "
+ f"convergence='{args.convergence}', refinement='{refine_stage}'"
+ )
+ print(
+ f"Parameters: particles={args.n_particles}, epochs={args.epochs}, seeds={args.seeds}"
+ )
+ print("=" * 80)
+ if has_val:
+ print(
+ f"{'Method':<18} {'Seed':<6} {'Val Loss':<12} {'Val Accuracy':<12} {'Val MSE':<12} {'Time (s)':<10}"
+ )
+ else:
+ print(
+ f"{'Method':<18} {'Seed':<6} {'Loss':<12} {'Accuracy':<12} {'MSE':<12} {'Time (s)':<10}"
+ )
+ print("-" * 80)
+
+ for method_key in methods_to_test:
+ for seed in args.seeds:
+ x_tr, y_tr, val_data, model, loss_fn, task = loader(seed)
+
+ eff_fitness_size = (
+ min(fitness_size, x_tr.shape[0])
+ if fitness_size is not None
+ else None
+ )
+
+ c0 = args.c0
+ c1 = args.c1
+ w_min = args.w_min
+ w_max = args.w_max
+
+ neg_swarm = (
+ args.negative_swarm
+ if method_key not in ("fips", "clpso", "bare_bones")
+ else 0.0
+ )
+ mut_swarm = args.mutation_swarm if method_key != "bare_bones" else 0.0
+ vel_ratio = (
+ args.velocity_limit_ratio if method_key != "bare_bones" else None
+ )
+
+ kwargs: dict[str, Any] = {
+ "model": model,
+ "loss": loss_fn,
+ "task": task,
+ "method": method_key,
+ "initialization": args.initialization,
+ "evaluation": eval_stage,
+ "convergence": args.convergence,
+ "refinement": refine_stage,
+ "method_options": parsed_method_opts,
+ "n_particles": args.n_particles,
+ "c0": c0,
+ "c1": c1,
+ "w_min": w_min,
+ "w_max": w_max,
+ "negative_swarm": neg_swarm,
+ "mutation_swarm": mut_swarm,
+ "particle_min": args.particle_min,
+ "particle_max": args.particle_max,
+ "velocity_limit_ratio": vel_ratio,
+ "boundary_strategy": args.boundary_strategy,
+ "initial_position_noise": args.initial_position_noise,
+ "seed": seed,
+ "device": args.device,
+ "fitness_size": eff_fitness_size,
+ "convergence_patience": args.convergence_patience,
+ "convergence_min_delta": args.convergence_min_delta,
+ "convergence_monitor": args.convergence_monitor,
+ "refinement_epochs": refinement_epochs,
+ "refinement_lr": args.refinement_lr,
+ }
+
+ if method_key == "adaptive_moment":
+ if args.moment_blend is not None:
+ kwargs["moment_blend"] = args.moment_blend
+ elif "moment_blend" in parsed_method_opts:
+ kwargs["moment_blend"] = float(parsed_method_opts["moment_blend"])
+ else:
+ kwargs["moment_blend"] = 0.25
+
+ if args.moment_beta1 is not None:
+ kwargs["moment_beta1"] = args.moment_beta1
+ if args.moment_beta2 is not None:
+ kwargs["moment_beta2"] = args.moment_beta2
+ if args.moment_step_size is not None:
+ kwargs["moment_step_size"] = args.moment_step_size
+ if args.moment_epsilon is not None:
+ kwargs["moment_epsilon"] = args.moment_epsilon
+
+ opt = Optimizer(**kwargs)
+
+ start_t = time.perf_counter()
+ best_score = opt.fit(
+ x_tr,
+ y_tr,
+ epochs=args.epochs,
+ batch_size=args.batch_size,
+ fitness_size=eff_fitness_size,
+ renewal=args.renewal,
+ validation_data=val_data,
+ output_dir=None,
+ refinement_epochs=refinement_epochs,
+ refinement_lr=args.refinement_lr,
+ )
+ elapsed_t = time.perf_counter() - start_t
+
+ tr_loss, tr_acc, tr_mse = best_score
+ if val_data is not None:
+ val_x, val_y = val_data
+ val_score = opt.evaluate(val_x, val_y)
+ eval_loss, eval_acc, eval_mse = val_score
+ score_src = "validation"
+ else:
+ eval_loss, eval_acc, eval_mse = tr_loss, tr_acc, tr_mse
+ score_src = "training"
+
+ results.append(
+ {
+ "method": method_key,
+ "seed": seed,
+ "score_source": score_src,
+ "train_loss": tr_loss,
+ "train_accuracy": tr_acc,
+ "train_mse": tr_mse,
+ "eval_loss": eval_loss,
+ "eval_accuracy": eval_acc,
+ "eval_mse": eval_mse,
+ "loss": eval_loss,
+ "accuracy": eval_acc,
+ "mse": eval_mse,
+ "elapsed_time": elapsed_t,
+ }
+ )
+
+ print(
+ f"{method_key:<18} {seed:<6} {eval_loss:<12.6f} {eval_acc:<12.6f} {eval_mse:<12.6f} {elapsed_t:<10.4f}"
+ )
+
+ print("-" * 80)
+ print("\nAggregate Summary (Mean across seeds):")
+ print("=" * 80)
+ if has_val:
+ print(
+ f"{'Method':<18} {'Mean Val Loss':<14} {'Mean Val Acc':<14} {'Mean Val MSE':<14} {'Mean Time (s)':<12}"
+ )
+ else:
+ print(
+ f"{'Method':<18} {'Mean Loss':<12} {'Mean Acc':<12} {'Mean MSE':<12} {'Mean Time (s)':<12}"
+ )
+ print("-" * 80)
+
+ summary_list: list[dict[str, Any]] = []
+ for method_key in methods_to_test:
+ method_runs = [r for r in results if r["method"] == method_key]
+ if not method_runs:
+ continue
+ n_runs = len(method_runs)
+ mean_tr_loss = sum(r["train_loss"] for r in method_runs) / n_runs
+ mean_tr_acc = sum(r["train_accuracy"] for r in method_runs) / n_runs
+ mean_tr_mse = sum(r["train_mse"] for r in method_runs) / n_runs
+ mean_eval_loss = sum(r["eval_loss"] for r in method_runs) / n_runs
+ mean_eval_acc = sum(r["eval_accuracy"] for r in method_runs) / n_runs
+ mean_eval_mse = sum(r["eval_mse"] for r in method_runs) / n_runs
+ mean_time = sum(r["elapsed_time"] for r in method_runs) / n_runs
+ score_src = method_runs[0]["score_source"]
+
+ summary_entry = {
+ "method": method_key,
+ "title": available_m_plugins[method_key].title,
+ "source": available_m_plugins[method_key].source,
+ "score_source": score_src,
+ "mean_train_loss": mean_tr_loss,
+ "mean_train_accuracy": mean_tr_acc,
+ "mean_train_mse": mean_tr_mse,
+ "mean_eval_loss": mean_eval_loss,
+ "mean_eval_accuracy": mean_eval_acc,
+ "mean_eval_mse": mean_eval_mse,
+ "mean_loss": mean_eval_loss,
+ "mean_accuracy": mean_eval_acc,
+ "mean_mse": mean_eval_mse,
+ "mean_elapsed_time": mean_time,
+ "runs": n_runs,
+ }
+ summary_list.append(summary_entry)
+
+ if has_val:
+ print(
+ f"{method_key:<18} {mean_eval_loss:<14.6f} {mean_eval_acc:<14.6f} {mean_eval_mse:<14.6f} {mean_time:<12.4f}"
+ )
+ else:
+ print(
+ f"{method_key:<18} {mean_eval_loss:<12.6f} {mean_eval_acc:<12.6f} {mean_eval_mse:<12.6f} {mean_time:<12.4f}"
+ )
+ print("=" * 80)
+
+ if args.json_path:
+ payload = {
+ "dataset": args.dataset,
+ "score_source": "validation" if has_val else "training",
+ "selectors": {
+ "initialization": args.initialization,
+ "evaluation": eval_stage,
+ "convergence": args.convergence,
+ "refinement": refine_stage,
+ },
+ "parameters": {
+ "n_particles": args.n_particles,
+ "epochs": args.epochs,
+ "batch_size": args.batch_size,
+ "fitness_size": fitness_size,
+ "refinement_epochs": refinement_epochs,
+ "refinement_lr": args.refinement_lr,
+ "seeds": args.seeds,
+ },
+ "results": results,
+ "summary": summary_list,
+ }
+ with open(args.json_path, "w", encoding="utf-8") as f:
+ json.dump(payload, f, indent=2)
+ print(f"\nSaved comparison results JSON to: {args.json_path}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/deep_accuracy_study.py b/test/deep_accuracy_study.py
new file mode 100644
index 0000000..930bd63
--- /dev/null
+++ b/test/deep_accuracy_study.py
@@ -0,0 +1,932 @@
+"""
+MNIST Deep Accuracy Study: Architecture vs Optimizer Profiles
+
+Evaluates official MNIST (60,000 train / 10,000 test) across:
+1. Architecture Lane: Raw Linear, Raw MLP, Compact CNN under standard full-data Adam.
+2. Optimizer Lane: Adam-Only, PSO-Only (adaptive_moment on 2k subset), and Hybrid (PSO warm start + Adam fine-tuning) on Compact CNN.
+
+Contract:
+- Official 60k train / 10k test split with train-only statistics normalization (no PCA).
+- Avoid BatchNorm/Dropout so PSO and eval semantics match.
+- Seed model construction identically per seed to preserve explicit initial state fingerprint across lanes.
+- Fixed no-scheduler contract for Adam with CrossEntropyLoss and lr=1e-3.
+"""
+
+import argparse
+import csv
+import datetime
+import json
+import math
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+
+# Ensure test/ directory is in sys.path
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from benchmark_suite import (
+ calc_stats,
+ compute_data_fingerprint,
+ compute_model_fingerprint,
+ extract_plugin_metadata,
+ get_hardware_provenance,
+ resolve_execution_device,
+ save_json_atomic,
+ sync_device,
+)
+from pso import Optimizer, __version__ as pso_version
+
+DEEP_ACCURACY_PROTOCOL_VERSION = "1.0.0"
+
+
+# ==========================================
+# Data Preparation (No PCA, Raw 1x28x28)
+# ==========================================
+
+def prepare_deep_accuracy_mnist_data() -> Tuple[
+ torch.Tensor,
+ torch.Tensor,
+ torch.Tensor,
+ torch.Tensor,
+ str,
+ Dict[str, Any],
+]:
+ """
+ Loads official torchvision MNIST dataset (60,000 train / 10,000 test).
+ Normalizes images using train-only mean and std (no PCA).
+ Validates sample counts and label range [0, 9].
+ Returns (x_train, y_train, x_test, y_test, data_fingerprint, provenance_dict).
+ """
+ from torchvision.datasets import MNIST
+
+ cache_dir = Path("result/cache")
+ cache_dir.mkdir(parents=True, exist_ok=True)
+ train_dataset = MNIST(root=str(cache_dir), train=True, download=True)
+ test_dataset = MNIST(root=str(cache_dir), train=False, download=True)
+
+ n_train = len(train_dataset.data)
+ n_test = len(test_dataset.data)
+ if n_train != 60000:
+ raise ValueError(f"Expected 60,000 training samples; got {n_train}")
+ if n_test != 10000:
+ raise ValueError(f"Expected 10,000 test samples; got {n_test}")
+
+ y_train = train_dataset.targets.long()
+ y_test = test_dataset.targets.long()
+
+ min_tr, max_tr = int(y_train.min()), int(y_train.max())
+ min_te, max_te = int(y_test.min()), int(y_test.max())
+ if min_tr != 0 or max_tr != 9:
+ raise ValueError(f"Train label range must be [0, 9]; got [{min_tr}, {max_tr}]")
+ if min_te != 0 or max_te != 9:
+ raise ValueError(f"Test label range must be [0, 9]; got [{min_te}, {max_te}]")
+
+ x_train_raw = train_dataset.data.float() / 255.0 # (60000, 28, 28)
+ x_test_raw = test_dataset.data.float() / 255.0 # (10000, 28, 28)
+
+ # Compute normalization statistics from TRAIN split only
+ mean_val = float(x_train_raw.mean())
+ std_val = float(x_train_raw.std())
+
+ x_train_norm = ((x_train_raw - mean_val) / std_val).unsqueeze(1) # (60000, 1, 28, 28)
+ x_test_norm = ((x_test_raw - mean_val) / std_val).unsqueeze(1) # (10000, 1, 28, 28)
+
+ data_fp = compute_data_fingerprint(x_train_norm, x_test_norm, y_train, y_test)
+ normalization_provenance = {
+ "input_shape": [1, 28, 28],
+ "pca": False,
+ "raw_inputs": True,
+ "normalization_scope": "official_train_split_60000_only",
+ "train_mean": round(mean_val, 6),
+ "train_std": round(std_val, 6),
+ "train_samples": 60000,
+ "test_samples": 10000,
+ }
+ return x_train_norm, y_train, x_test_norm, y_test, data_fp, normalization_provenance
+
+
+# ==========================================
+# Architectures (No BatchNorm / No Dropout)
+# ==========================================
+
+def count_parameters(model: nn.Module) -> int:
+ return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+
+def make_raw_linear(seed: int = 41) -> nn.Module:
+ torch.manual_seed(seed)
+ return nn.Sequential(
+ nn.Flatten(),
+ nn.Linear(784, 10),
+ )
+
+
+def make_raw_mlp(seed: int = 41) -> nn.Module:
+ torch.manual_seed(seed)
+ return nn.Sequential(
+ nn.Flatten(),
+ nn.Linear(784, 128),
+ nn.ReLU(),
+ nn.Linear(128, 64),
+ nn.ReLU(),
+ nn.Linear(64, 10),
+ )
+
+
+class CompactCNN(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.conv1 = nn.Conv2d(1, 8, kernel_size=3, padding=1)
+ self.relu1 = nn.ReLU()
+ self.pool1 = nn.MaxPool2d(2, 2)
+ self.conv2 = nn.Conv2d(8, 16, kernel_size=3, padding=1)
+ self.relu2 = nn.ReLU()
+ self.pool2 = nn.MaxPool2d(2, 2)
+ self.flatten = nn.Flatten()
+ self.fc = nn.Linear(784, 10)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if x.dim() == 2 and x.shape[1] == 784:
+ x = x.view(-1, 1, 28, 28)
+ out = self.pool1(self.relu1(self.conv1(x)))
+ out = self.pool2(self.relu2(self.conv2(out)))
+ out = self.flatten(out)
+ return self.fc(out)
+
+
+def make_compact_cnn(seed: int = 41) -> nn.Module:
+ torch.manual_seed(seed)
+ return CompactCNN()
+
+
+# ==========================================
+# Evaluation & Training Routines
+# ==========================================
+
+def evaluate_model_on_test(
+ model: nn.Module,
+ x_test: torch.Tensor,
+ y_test: torch.Tensor,
+ device: torch.device,
+ batch_size: int = 512,
+) -> Tuple[float, float]:
+ """
+ Evaluates model on test data without gradients.
+ Returns (test_loss, test_accuracy).
+ """
+ model.to(device)
+ model.eval()
+ criterion = nn.CrossEntropyLoss()
+ total_loss = 0.0
+ correct = 0
+ total = 0
+
+ with torch.no_grad():
+ n_test = x_test.shape[0]
+ for i in range(0, n_test, batch_size):
+ bx = x_test[i : i + batch_size].to(device)
+ by = y_test[i : i + batch_size].to(device)
+ outputs = model(bx)
+ loss = criterion(outputs, by)
+ total_loss += loss.item() * bx.size(0)
+ preds = outputs.argmax(dim=1)
+ correct += (preds == by).sum().item()
+ total += bx.size(0)
+
+ avg_loss = total_loss / total if total > 0 else 0.0
+ accuracy = correct / total if total > 0 else 0.0
+ return float(avg_loss), float(accuracy)
+
+
+def train_adam_routine(
+ model: nn.Module,
+ x_train: torch.Tensor,
+ y_train: torch.Tensor,
+ x_test: torch.Tensor,
+ y_test: torch.Tensor,
+ epochs: int,
+ batch_size: int,
+ lr: float,
+ seed: int,
+ device: torch.device,
+) -> Tuple[List[Dict[str, Any]], float, float, float]:
+ """
+ Standard full-data Adam training routine with CrossEntropyLoss, Adam lr, fixed no-scheduler contract.
+ Returns (history, final_test_loss, final_test_acc, elapsed_sec).
+ """
+ model.to(device)
+ optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+ criterion = nn.CrossEntropyLoss()
+
+ generator = torch.Generator().manual_seed(seed)
+ n_train = x_train.shape[0]
+
+ history = []
+ init_loss, init_acc = evaluate_model_on_test(model, x_test, y_test, device)
+ history.append({"epoch": 0, "test_loss": round(init_loss, 6), "test_acc": round(init_acc, 6)})
+
+ sync_device(device)
+ t0 = time.time()
+ for epoch in range(1, epochs + 1):
+ model.train()
+ perm = torch.randperm(n_train, generator=generator)
+ for i in range(0, n_train, batch_size):
+ indices = perm[i : i + batch_size]
+ bx = x_train[indices].to(device)
+ by = y_train[indices].to(device)
+ optimizer.zero_grad()
+ outputs = model(bx)
+ loss = criterion(outputs, by)
+ loss.backward()
+ optimizer.step()
+
+ test_loss, test_acc = evaluate_model_on_test(model, x_test, y_test, device)
+ history.append({
+ "epoch": epoch,
+ "test_loss": round(test_loss, 6),
+ "test_acc": round(test_acc, 6),
+ })
+
+ sync_device(device)
+ elapsed = time.time() - t0
+
+ final_loss = history[-1]["test_loss"]
+ final_acc = history[-1]["test_acc"]
+ return history, final_loss, final_acc, elapsed
+
+
+def run_pso_routine(
+ model: nn.Module,
+ x_train: torch.Tensor,
+ y_train: torch.Tensor,
+ x_test: torch.Tensor,
+ y_test: torch.Tensor,
+ pso_epochs: int,
+ n_particles: int,
+ fitness_size: int,
+ seed: int,
+ device: torch.device,
+) -> Tuple[nn.Module, Dict[str, float], float, float, Dict[str, Any]]:
+ """
+ PSO-only adaptive_moment on fixed train subset without gradient refinement.
+ Returns (best_model, fitness_score_dict, test_loss, test_acc, pso_metadata).
+ """
+ model.to(device)
+ loss_fn = nn.CrossEntropyLoss()
+
+ opt = Optimizer(
+ model=model,
+ loss=loss_fn,
+ task="multiclass",
+ method="adaptive_moment",
+ evaluation="fixed_subset",
+ fitness_size=fitness_size,
+ n_particles=n_particles,
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ particle_min=-3.0,
+ particle_max=3.0,
+ boundary_strategy="reflect",
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ initialization="model_noise",
+ initial_position_noise=0.05,
+ moment_blend=0.06,
+ moment_step_size=0.5,
+ moment_beta1=0.9,
+ seed=seed,
+ device=device,
+ )
+
+ t0 = time.time()
+ opt.fit(x_train, y_train, epochs=pso_epochs)
+ sync_device(device)
+ elapsed = time.time() - t0
+
+ best_model = opt.get_best_model()
+ best_score_tuple = opt.get_best_score()
+ fitness_score = {
+ "subset_loss": round(float(best_score_tuple[0]), 6),
+ "subset_acc": round(float(best_score_tuple[1]), 6),
+ "subset_mse": round(float(best_score_tuple[2]), 6),
+ }
+
+ test_loss, test_acc = evaluate_model_on_test(best_model, x_test, y_test, device)
+ plugin_meta = extract_plugin_metadata(opt)
+
+ pso_meta = {
+ "elapsed_sec": round(elapsed, 4),
+ "particles": n_particles,
+ "pso_epochs": pso_epochs,
+ "fitness_size": fitness_size,
+ "plugins": plugin_meta,
+ }
+ return best_model, fitness_score, float(test_loss), float(test_acc), pso_meta
+
+
+# ==========================================
+# Output Generation (CSV, Plot)
+# ==========================================
+
+def save_csv_records(records: List[Dict[str, Any]], csv_path: Path):
+ csv_path.parent.mkdir(parents=True, exist_ok=True)
+ fieldnames = [
+ "lane",
+ "profile_or_arch",
+ "seed",
+ "model_name",
+ "param_count",
+ "initial_test_acc",
+ "final_test_acc",
+ "final_test_loss",
+ "subset_fitness_acc",
+ "subset_fitness_loss",
+ "pso_epochs",
+ "adam_epochs",
+ "elapsed_sec",
+ "model_fingerprint",
+ "data_fingerprint",
+ ]
+ with open(csv_path, "w", newline="", encoding="utf-8") as f:
+ writer = csv.DictWriter(f, fieldnames=fieldnames)
+ writer.writeheader()
+ for r in records:
+ writer.writerow({
+ "lane": r.get("lane"),
+ "profile_or_arch": r.get("profile_or_arch"),
+ "seed": r.get("seed"),
+ "model_name": r.get("model_name"),
+ "param_count": r.get("param_count"),
+ "initial_test_acc": r.get("initial_test_acc"),
+ "final_test_acc": r.get("final_test_acc"),
+ "final_test_loss": r.get("final_test_loss"),
+ "subset_fitness_acc": r.get("subset_fitness_acc"),
+ "subset_fitness_loss": r.get("subset_fitness_loss"),
+ "pso_epochs": r.get("pso_epochs"),
+ "adam_epochs": r.get("adam_epochs"),
+ "elapsed_sec": r.get("elapsed_sec"),
+ "model_fingerprint": r.get("model_fingerprint"),
+ "data_fingerprint": r.get("data_fingerprint"),
+ })
+
+
+def render_plots(
+ arch_summary: Dict[str, Dict[str, float]],
+ opt_summary: Dict[str, Dict[str, float]],
+ figure_path: Path,
+):
+ figure_path.parent.mkdir(parents=True, exist_ok=True)
+ fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
+
+ if arch_summary:
+ arch_labels = list(arch_summary.keys())
+ arch_means = [arch_summary[k]["mean"] * 100 for k in arch_labels]
+ arch_sds = [arch_summary[k]["std"] * 100 for k in arch_labels]
+ arch_display = {
+ "raw_linear": "Raw Linear",
+ "raw_mlp": "Raw MLP",
+ "compact_cnn": "Compact CNN",
+ }
+
+ x_arch = np.arange(len(arch_labels))
+ ax1.bar(x_arch, arch_means, yerr=arch_sds, capsize=5, color="#56B4E9", edgecolor="black", alpha=0.85)
+ ax1.axhline(98.0, color="red", linestyle="--", linewidth=1.5, label="98% Target")
+ ax1.set_xticks(x_arch)
+ ax1.set_xticklabels([arch_display[k] for k in arch_labels], rotation=15)
+ ax1.set_ylabel("Final Test Accuracy (%)")
+ ax1.set_title("Architecture Lane (Full-Data Adam)")
+ ax1.set_ylim(0, 110)
+ ax1.set_axisbelow(True)
+ ax1.grid(axis="y", linestyle=":", alpha=0.6)
+ ax1.legend(loc="lower left")
+
+ for i, (m, sd) in enumerate(zip(arch_means, arch_sds)):
+ ax1.text(
+ i,
+ 105.0 if m >= 90.0 else min(m + sd + 1.5, 102.5),
+ f"{m:.2f}%",
+ ha="center",
+ va="bottom",
+ fontsize=9,
+ fontweight="bold",
+ bbox={"facecolor": "white", "edgecolor": "none", "alpha": 0.9, "pad": 1.5},
+ )
+
+ if opt_summary:
+ opt_labels = list(opt_summary.keys())
+ opt_means = [opt_summary[k]["mean"] * 100 for k in opt_labels]
+ opt_sds = [opt_summary[k]["std"] * 100 for k in opt_labels]
+ opt_display = {
+ "adam_only": "Adam Only",
+ "pso_only": "PSO Only",
+ "hybrid": "PSO → Adam",
+ }
+
+ x_opt = np.arange(len(opt_labels))
+ colors = ["#009E73", "#E69F00", "#CC79A7"]
+ ax2.bar(x_opt, opt_means, yerr=opt_sds, capsize=5, color=colors[:len(opt_labels)], edgecolor="black", alpha=0.85)
+ ax2.axhline(98.0, color="red", linestyle="--", linewidth=1.5, label="98% Target")
+ ax2.set_xticks(x_opt)
+ ax2.set_xticklabels([opt_display[k] for k in opt_labels], rotation=15)
+ ax2.set_ylabel("Final Test Accuracy (%)")
+ ax2.set_title("Optimizer Lane (Compact CNN)")
+ ax2.set_ylim(0, 110)
+ ax2.set_axisbelow(True)
+ ax2.grid(axis="y", linestyle=":", alpha=0.6)
+ ax2.legend(loc="lower left")
+
+ for i, (m, sd) in enumerate(zip(opt_means, opt_sds)):
+ ax2.text(
+ i,
+ 105.0 if m >= 90.0 else min(m + sd + 1.5, 102.5),
+ f"{m:.2f}%",
+ ha="center",
+ va="bottom",
+ fontsize=9,
+ fontweight="bold",
+ bbox={"facecolor": "white", "edgecolor": "none", "alpha": 0.9, "pad": 1.5},
+ )
+
+ plt.suptitle("MNIST Deep Accuracy Study: Architectures & Optimizer Profiles", fontsize=14, fontweight="bold")
+ plt.tight_layout()
+ fig.savefig(figure_path, dpi=300)
+ plt.close(fig)
+
+
+# ==========================================
+# Main CLI & Runner
+# ==========================================
+
+def parse_args() -> argparse.Namespace:
+ parser = argparse.ArgumentParser(
+ description="MNIST Deep Accuracy Study: Architecture vs Optimizer Profiles"
+ )
+ parser.add_argument(
+ "--seeds",
+ type=str,
+ default="101,102,103",
+ help="Comma-separated random seeds (default: 101,102,103)",
+ )
+ parser.add_argument(
+ "--adam-epochs",
+ type=int,
+ default=10,
+ help="Full-data Adam training epochs (default: 10)",
+ )
+ parser.add_argument(
+ "--pso-epochs",
+ type=int,
+ default=40,
+ help="PSO swarm optimization epochs (default: 40)",
+ )
+ parser.add_argument(
+ "--particles",
+ "--n-particles",
+ type=int,
+ default=30,
+ dest="particles",
+ help="Number of PSO particles (default: 30)",
+ )
+ parser.add_argument(
+ "--fitness-size",
+ type=int,
+ default=2000,
+ help="Fixed train subset fitness size for PSO (default: 2000)",
+ )
+ parser.add_argument(
+ "--batch-size",
+ type=int,
+ default=256,
+ help="Batch size for Adam DataLoader (default: 256)",
+ )
+ parser.add_argument(
+ "--lr",
+ "--learning-rate",
+ type=float,
+ default=1e-3,
+ dest="lr",
+ help="Learning rate for Adam optimizer (default: 1e-3)",
+ )
+ parser.add_argument(
+ "--device",
+ type=str,
+ default=None,
+ help="Target PyTorch device ('cpu', 'cuda', 'mps'; default: auto-detect)",
+ )
+ parser.add_argument(
+ "--json-path",
+ type=str,
+ default="benchmark_results/pso_v4_deep_accuracy.json",
+ help="JSON result output path (default: benchmark_results/pso_v4_deep_accuracy.json)",
+ )
+ parser.add_argument(
+ "--csv-path",
+ type=str,
+ default="benchmark_results/pso_v4_deep_accuracy.csv",
+ help="CSV result output path (default: benchmark_results/pso_v4_deep_accuracy.csv)",
+ )
+ parser.add_argument(
+ "--figure-path",
+ "--plot-path",
+ type=str,
+ default="history_plt/pso_v4_deep_accuracy.png",
+ dest="figure_path",
+ help="Figure output path (default: history_plt/pso_v4_deep_accuracy.png)",
+ )
+ parser.add_argument(
+ "--lanes",
+ "--profiles",
+ type=str,
+ choices=["all", "architectures", "optimizers"],
+ default="all",
+ help="Lanes/profiles to evaluate (choices: all, architectures, optimizers; default: all)",
+ )
+ return parser.parse_args()
+
+
+def main():
+ args = parse_args()
+ seed_list = [int(s.strip()) for s in args.seeds.split(",") if s.strip()]
+ if not seed_list:
+ raise ValueError("--seeds must contain at least one integer")
+ if len(seed_list) != len(set(seed_list)):
+ raise ValueError("--seeds must not contain duplicates")
+ if any(seed < 0 for seed in seed_list):
+ raise ValueError("--seeds values must be non-negative")
+ for name, value in (
+ ("--adam-epochs", args.adam_epochs),
+ ("--pso-epochs", args.pso_epochs),
+ ("--particles", args.particles),
+ ("--fitness-size", args.fitness_size),
+ ("--batch-size", args.batch_size),
+ ):
+ if value <= 0:
+ raise ValueError(f"{name} must be positive")
+ if not math.isfinite(args.lr) or args.lr <= 0.0:
+ raise ValueError("--lr must be a positive finite number")
+
+ device = resolve_execution_device(args.device)
+
+ json_path = Path(args.json_path)
+ csv_path = Path(args.csv_path)
+ figure_path = Path(args.figure_path)
+
+ print(f"=== Starting MNIST Deep Accuracy Study (Protocol v{DEEP_ACCURACY_PROTOCOL_VERSION}) ===")
+ print(f"Device: {device} | Seeds: {seed_list} | Adam Epochs: {args.adam_epochs} | PSO Epochs: {args.pso_epochs}")
+ print(f"Particles: {args.particles} | Fitness Size: {args.fitness_size} | Batch Size: {args.batch_size} | LR: {args.lr}")
+
+ # Prepare data
+ x_train, y_train, x_test, y_test, data_fp, norm_provenance = prepare_deep_accuracy_mnist_data()
+ print(f"Data Loaded: Train {x_train.shape[0]} / Test {x_test.shape[0]} | Fingerprint: {data_fp[:12]}...")
+
+ hardware_prov = get_hardware_provenance(device)
+ all_csv_records: List[Dict[str, Any]] = []
+ architecture_lane_runs: List[Dict[str, Any]] = []
+ optimizer_lane_runs: List[Dict[str, Any]] = []
+
+ # Map architecture factories
+ arch_factories = {
+ "raw_linear": ("Raw Linear (784->10)", make_raw_linear),
+ "raw_mlp": ("Raw MLP (784->128->64->10)", make_raw_mlp),
+ "compact_cnn": ("Compact CNN (9,098 params)", make_compact_cnn),
+ }
+
+ try:
+ # ----------------------------------------------------
+ # 1. Architecture Lane
+ # ----------------------------------------------------
+ compact_cnn_adam_cache: Dict[int, Dict[str, Any]] = {}
+
+ if args.lanes in ("all", "architectures"):
+ print("\n--- Running Architecture Lane (Full-Data Adam) ---")
+ for arch_key, (arch_name, factory) in arch_factories.items():
+ for s in seed_list:
+ # Construct base model and record initial fingerprint
+ model = factory(seed=s)
+ p_count = count_parameters(model)
+ init_fp = compute_model_fingerprint(model)
+
+ init_loss, init_acc = evaluate_model_on_test(model, x_test, y_test, device)
+
+ print(f"[Arch: {arch_key} | Seed: {s}] Params: {p_count} | Init Acc: {init_acc*100:.2f}% | Training Adam...")
+
+ history, final_loss, final_acc, elapsed = train_adam_routine(
+ model=model,
+ x_train=x_train,
+ y_train=y_train,
+ x_test=x_test,
+ y_test=y_test,
+ epochs=args.adam_epochs,
+ batch_size=args.batch_size,
+ lr=args.lr,
+ seed=s,
+ device=device,
+ )
+
+ run_record = {
+ "lane": "architecture",
+ "profile_or_arch": arch_key,
+ "seed": s,
+ "model_name": arch_name,
+ "param_count": p_count,
+ "initial_test_acc": round(init_acc, 6),
+ "final_test_acc": round(final_acc, 6),
+ "final_test_loss": round(final_loss, 6),
+ "subset_fitness_acc": None,
+ "subset_fitness_loss": None,
+ "pso_epochs": 0,
+ "adam_epochs": args.adam_epochs,
+ "elapsed_sec": round(elapsed, 4),
+ "model_fingerprint": init_fp,
+ "data_fingerprint": data_fp,
+ "epoch_history": history,
+ }
+ architecture_lane_runs.append(run_record)
+ all_csv_records.append(run_record)
+
+ if arch_key == "compact_cnn":
+ compact_cnn_adam_cache[s] = run_record
+
+ print(f" -> Final Test Acc: {final_acc*100:.2f}% | Loss: {final_loss:.4f} | Time: {elapsed:.2f}s")
+
+ # ----------------------------------------------------
+ # 2. Optimizer Lane (Compact CNN)
+ # ----------------------------------------------------
+ if args.lanes in ("all", "optimizers"):
+ print("\n--- Running Optimizer Lane (Compact CNN) ---")
+ profiles = ["adam_only", "pso_only", "hybrid"]
+
+ for prof in profiles:
+ for s in seed_list:
+ # Construct Compact CNN with seed s to ensure same base initial state
+ model_base = make_compact_cnn(seed=s)
+ p_count = count_parameters(model_base)
+ init_fp = compute_model_fingerprint(model_base)
+ init_loss, init_acc = evaluate_model_on_test(model_base, x_test, y_test, device)
+
+ if prof == "adam_only":
+ if s in compact_cnn_adam_cache:
+ # Explicitly reuse record from Architecture Lane
+ cached = compact_cnn_adam_cache[s]
+ run_record = {
+ "lane": "optimizer",
+ "profile_or_arch": "adam_only",
+ "seed": s,
+ "model_name": "Compact CNN (Adam-Only)",
+ "param_count": p_count,
+ "initial_test_acc": cached["initial_test_acc"],
+ "final_test_acc": cached["final_test_acc"],
+ "final_test_loss": cached["final_test_loss"],
+ "subset_fitness_acc": None,
+ "subset_fitness_loss": None,
+ "pso_epochs": 0,
+ "adam_epochs": args.adam_epochs,
+ "elapsed_sec": cached["elapsed_sec"],
+ "model_fingerprint": init_fp,
+ "data_fingerprint": data_fp,
+ "reused_from_architecture_lane": True,
+ "epoch_history": cached["epoch_history"],
+ }
+ print(f"[Opt: adam_only | Seed: {s}] Reused from Architecture Lane | Final Acc: {cached['final_test_acc']*100:.2f}%")
+ else:
+ print(f"[Opt: adam_only | Seed: {s}] Training Adam...")
+ history, final_loss, final_acc, elapsed = train_adam_routine(
+ model=model_base,
+ x_train=x_train,
+ y_train=y_train,
+ x_test=x_test,
+ y_test=y_test,
+ epochs=args.adam_epochs,
+ batch_size=args.batch_size,
+ lr=args.lr,
+ seed=s,
+ device=device,
+ )
+ run_record = {
+ "lane": "optimizer",
+ "profile_or_arch": "adam_only",
+ "seed": s,
+ "model_name": "Compact CNN (Adam-Only)",
+ "param_count": p_count,
+ "initial_test_acc": round(init_acc, 6),
+ "final_test_acc": round(final_acc, 6),
+ "final_test_loss": round(final_loss, 6),
+ "subset_fitness_acc": None,
+ "subset_fitness_loss": None,
+ "pso_epochs": 0,
+ "adam_epochs": args.adam_epochs,
+ "elapsed_sec": round(elapsed, 4),
+ "model_fingerprint": init_fp,
+ "data_fingerprint": data_fp,
+ "reused_from_architecture_lane": False,
+ "epoch_history": history,
+ }
+ print(f" -> Final Test Acc: {final_acc*100:.2f}% | Loss: {final_loss:.4f} | Time: {elapsed:.2f}s")
+
+ optimizer_lane_runs.append(run_record)
+ all_csv_records.append(run_record)
+
+ elif prof == "pso_only":
+ print(
+ f"[Opt: pso_only | Seed: {s}] Running PSO Adaptive Moment "
+ f"on {args.fitness_size:,} fixed-subset samples..."
+ )
+ best_model, fitness_score, pso_test_loss, pso_test_acc, pso_meta = run_pso_routine(
+ model=model_base,
+ x_train=x_train,
+ y_train=y_train,
+ x_test=x_test,
+ y_test=y_test,
+ pso_epochs=args.pso_epochs,
+ n_particles=args.particles,
+ fitness_size=args.fitness_size,
+ seed=s,
+ device=device,
+ )
+
+ run_record = {
+ "lane": "optimizer",
+ "profile_or_arch": "pso_only",
+ "seed": s,
+ "model_name": "Compact CNN (PSO-Only)",
+ "param_count": p_count,
+ "initial_test_acc": round(init_acc, 6),
+ "final_test_acc": round(pso_test_acc, 6),
+ "final_test_loss": round(pso_test_loss, 6),
+ "subset_fitness_acc": fitness_score["subset_acc"],
+ "subset_fitness_loss": fitness_score["subset_loss"],
+ "pso_epochs": args.pso_epochs,
+ "adam_epochs": 0,
+ "elapsed_sec": pso_meta["elapsed_sec"],
+ "model_fingerprint": init_fp,
+ "data_fingerprint": data_fp,
+ "pso_metadata": pso_meta,
+ }
+ optimizer_lane_runs.append(run_record)
+ all_csv_records.append(run_record)
+
+ print(f" -> Fitness Subset Acc: {fitness_score['subset_acc']*100:.2f}% | Full Test Acc: {pso_test_acc*100:.2f}% | Time: {pso_meta['elapsed_sec']:.2f}s")
+
+ elif prof == "hybrid":
+ print(f"[Opt: hybrid | Seed: {s}] Running Hybrid (PSO Warm Start + Adam Fine-Tuning)...")
+ # 1. PSO Warm Start
+ t_hyb_start = time.time()
+ pso_best_model, fitness_score, pso_test_loss, pso_test_acc, pso_meta = run_pso_routine(
+ model=model_base,
+ x_train=x_train,
+ y_train=y_train,
+ x_test=x_test,
+ y_test=y_test,
+ pso_epochs=args.pso_epochs,
+ n_particles=args.particles,
+ fitness_size=args.fitness_size,
+ seed=s,
+ device=device,
+ )
+
+ # 2. Continue with full-data Adam
+ post_adam_history, final_test_loss, final_test_acc, adam_elapsed = train_adam_routine(
+ model=pso_best_model,
+ x_train=x_train,
+ y_train=y_train,
+ x_test=x_test,
+ y_test=y_test,
+ epochs=args.adam_epochs,
+ batch_size=args.batch_size,
+ lr=args.lr,
+ seed=s,
+ device=device,
+ )
+ hyb_total_elapsed = time.time() - t_hyb_start
+
+ run_record = {
+ "lane": "optimizer",
+ "profile_or_arch": "hybrid",
+ "seed": s,
+ "model_name": "Compact CNN (Hybrid)",
+ "param_count": p_count,
+ "initial_test_acc": round(init_acc, 6),
+ "final_test_acc": round(final_test_acc, 6),
+ "final_test_loss": round(final_test_loss, 6),
+ "subset_fitness_acc": fitness_score["subset_acc"],
+ "subset_fitness_loss": fitness_score["subset_loss"],
+ "pso_epochs": args.pso_epochs,
+ "adam_epochs": args.adam_epochs,
+ "elapsed_sec": round(hyb_total_elapsed, 4),
+ "model_fingerprint": init_fp,
+ "data_fingerprint": data_fp,
+ "post_pso_test_acc": round(pso_test_acc, 6),
+ "post_pso_test_loss": round(pso_test_loss, 6),
+ "post_adam_history": post_adam_history,
+ "efficiency_label": "HYBRID_GETS_EXTRA_WORK_UNFAIR_EFFICIENCY_COMPARISON",
+ }
+ optimizer_lane_runs.append(run_record)
+ all_csv_records.append(run_record)
+
+ print(f" -> Post-PSO Test Acc: {pso_test_acc*100:.2f}% | Final Hybrid Test Acc: {final_test_acc*100:.2f}% | Time: {hyb_total_elapsed:.2f}s")
+
+ # Compute summary statistics
+ arch_summary: Dict[str, Dict[str, float]] = {}
+ for arch_key in arch_factories.keys():
+ vals = [r["final_test_acc"] for r in architecture_lane_runs if r["profile_or_arch"] == arch_key]
+ if vals:
+ arch_summary[arch_key] = calc_stats(vals)
+
+ opt_summary: Dict[str, Dict[str, float]] = {}
+ for prof in ["adam_only", "pso_only", "hybrid"]:
+ vals = [r["final_test_acc"] for r in optimizer_lane_runs if r["profile_or_arch"] == prof]
+ if vals:
+ opt_summary[prof] = calc_stats(vals)
+
+ # Structure complete JSON output
+ result_payload = {
+ "protocol_version": DEEP_ACCURACY_PROTOCOL_VERSION,
+ "pso_version": pso_version,
+ "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+ "completed": True,
+ "error": None,
+ "hardware_provenance": hardware_prov,
+ "data_provenance": norm_provenance,
+ "data_fingerprint": data_fp,
+ "configuration": {
+ "seeds": seed_list,
+ "adam_epochs": args.adam_epochs,
+ "pso_epochs": args.pso_epochs,
+ "particles": args.particles,
+ "fitness_size": args.fitness_size,
+ "batch_size": args.batch_size,
+ "lr": args.lr,
+ "device": str(device),
+ },
+ "summaries": {
+ "architecture_lane": arch_summary,
+ "optimizer_lane": opt_summary,
+ },
+ "architecture_lane_runs": architecture_lane_runs,
+ "optimizer_lane_runs": optimizer_lane_runs,
+ }
+
+ # Save JSON output atomically
+ save_json_atomic(result_payload, json_path)
+ print(f"\nSaved JSON results to {json_path}")
+
+ # Save CSV records and render plot only after all runs succeed
+ save_csv_records(all_csv_records, csv_path)
+ print(f"Saved CSV records to {csv_path}")
+
+ render_plots(arch_summary, opt_summary, figure_path)
+ print(f"Saved summary figure to {figure_path}")
+
+ # Print final summary table
+ print("\n========================================================")
+ print(" FINAL SUMMARY TABLE ")
+ print("========================================================")
+ if arch_summary:
+ print("Architecture Lane (Full-Data Adam):")
+ for arch_key, stats in arch_summary.items():
+ print(f" - {arch_key:15s}: Mean Acc = {stats['mean']*100:6.2f}% ± {stats['std']*100:5.2f}% (Median: {stats['median']*100:.2f}%)")
+ if opt_summary:
+ print("\nOptimizer Lane (Compact CNN):")
+ for prof, stats in opt_summary.items():
+ print(f" - {prof:15s}: Mean Acc = {stats['mean']*100:6.2f}% ± {stats['std']*100:5.2f}% (Median: {stats['median']*100:.2f}%)")
+ print("========================================================\n")
+
+ except Exception as e:
+ error_payload = {
+ "protocol_version": DEEP_ACCURACY_PROTOCOL_VERSION,
+ "pso_version": pso_version,
+ "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+ "completed": False,
+ "error": str(e),
+ "hardware_provenance": hardware_prov,
+ "configuration": {
+ "seeds": seed_list,
+ "adam_epochs": args.adam_epochs,
+ "pso_epochs": args.pso_epochs,
+ "particles": args.particles,
+ "fitness_size": args.fitness_size,
+ "batch_size": args.batch_size,
+ "lr": args.lr,
+ "device": str(device),
+ },
+ "architecture_lane_runs": architecture_lane_runs,
+ "optimizer_lane_runs": optimizer_lane_runs,
+ }
+ save_json_atomic(error_payload, json_path)
+ print(f"\n[ERROR] Study failed: {e}")
+ print(f"Saved failure audit record to {json_path}")
+ sys.exit(1)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/deep_pso_methods.py b/test/deep_pso_methods.py
new file mode 100644
index 0000000..d1d8ef2
--- /dev/null
+++ b/test/deep_pso_methods.py
@@ -0,0 +1,1176 @@
+"""
+MNIST Deep PSO Methods Study: Latent Space Subspaces, Adaptive-Moment PSO, and Ensembling
+
+Protocol: MNIST-PSO-RAW-V5 1.0.0
+- Official raw MNIST (60,000 train / 10,000 test).
+- Split 60k train first into 50k search and 10k validation using deterministic stratified sampling (seed 20260902).
+- Mean and std fit on 50k search subset ONLY; applied to search, validation, and test.
+- Nested stratified ordering: 2k subset inside 10k subset inside 50k search set.
+- Base CompactCNN (9,098 parameters).
+- Latent subspace transform via deterministic sparse signed hash mapping for d in [290, 1024, 4096, full].
+- Exact base model at particle 0; remaining particles in antithetic pairs.
+- Device-resident latent adaptive-moment PSO (c0=c1=1.49618, w=0.7298, blend=0.06, step=0.5, beta1=0.9, beta2=0.999).
+- Lexicographical CE loss primary, accuracy tie-break selection.
+- Objective transition: complete pbest re-evaluation and gbest rebuild.
+- Validation-only pilot selection and elite selection.
+- Official 10k test set evaluated exactly once per final reported endpoint.
+"""
+
+import argparse
+import csv
+import datetime
+import hashlib
+import json
+import math
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+from sklearn.model_selection import train_test_split
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from benchmark_suite import (
+ calc_stats,
+ compute_data_fingerprint,
+ compute_model_fingerprint,
+ get_hardware_provenance,
+ resolve_execution_device,
+ save_json_atomic,
+ sync_device,
+)
+from pso import __version__ as pso_version
+
+PROTOCOL_VERSION = "MNIST-PSO-RAW-V5 1.0.0"
+
+
+# =====================================================================
+# 1. Architecture: CompactCNN (9,098 Parameters)
+# =====================================================================
+
+class CompactCNN(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.conv1 = nn.Conv2d(1, 8, kernel_size=3, padding=1)
+ self.relu1 = nn.ReLU()
+ self.pool1 = nn.MaxPool2d(2, 2)
+ self.conv2 = nn.Conv2d(8, 16, kernel_size=3, padding=1)
+ self.relu2 = nn.ReLU()
+ self.pool2 = nn.MaxPool2d(2, 2)
+ self.flatten = nn.Flatten()
+ self.fc = nn.Linear(784, 10)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if x.dim() == 2 and x.shape[1] == 784:
+ x = x.view(-1, 1, 28, 28)
+ out = self.pool1(self.relu1(self.conv1(x)))
+ out = self.pool2(self.relu2(self.conv2(out)))
+ out = self.flatten(out)
+ return self.fc(out)
+
+
+def make_compact_cnn(seed: int = 41) -> nn.Module:
+ torch.manual_seed(seed)
+ return CompactCNN()
+
+
+# =====================================================================
+# 2. Data Split, Normalization, & Stratified Subsets
+# =====================================================================
+
+def prepare_mnist_v5_data(
+ split_seed: int = 20260902,
+ cache_dir: Optional[Path] = None,
+) -> Tuple[
+ torch.Tensor, torch.Tensor,
+ torch.Tensor, torch.Tensor,
+ torch.Tensor, torch.Tensor,
+ Dict[int, torch.Tensor],
+ str, Dict[str, Any]
+]:
+ from torchvision.datasets import MNIST
+
+ if cache_dir is None:
+ cache_dir = Path("result/cache")
+ cache_dir.mkdir(parents=True, exist_ok=True)
+
+ raw_train = MNIST(root=str(cache_dir), train=True, download=True)
+ raw_test = MNIST(root=str(cache_dir), train=False, download=True)
+
+ x_train_raw = raw_train.data.float() / 255.0 # (60000, 28, 28)
+ y_train_raw = raw_train.targets.long()
+ x_test_raw = raw_test.data.float() / 255.0 # (10000, 28, 28)
+ y_test_raw = raw_test.targets.long()
+
+ # Stratified split: 50,000 search set and 10,000 validation set
+ indices = np.arange(len(y_train_raw))
+ search_idx, val_idx = train_test_split(
+ indices,
+ train_size=50000,
+ test_size=10000,
+ stratify=y_train_raw.numpy(),
+ random_state=split_seed,
+ )
+
+ x_search_raw = x_train_raw[search_idx]
+ y_search = y_train_raw[search_idx]
+ x_val_raw = x_train_raw[val_idx]
+ y_val = y_train_raw[val_idx]
+
+ # Fit mean and std on 50k search subset ONLY
+ mean_val = float(x_search_raw.mean())
+ std_val = float(x_search_raw.std())
+
+ x_search_norm = ((x_search_raw - mean_val) / std_val).unsqueeze(1) # (50000, 1, 28, 28)
+ x_val_norm = ((x_val_raw - mean_val) / std_val).unsqueeze(1) # (10000, 1, 28, 28)
+ x_test_norm = ((x_test_raw - mean_val) / std_val).unsqueeze(1) # (10000, 1, 28, 28)
+
+ # Nested stratified subsets inside 50k search set: 2k inside 10k inside 50k
+ nested_subsets = build_nested_stratified_subsets(
+ y_search=y_search,
+ subset_sizes=[2000, 10000, 50000],
+ subset_seed=split_seed,
+ )
+
+ # Data fingerprint over search and test
+ data_fp = compute_data_fingerprint(x_search_norm, x_test_norm, y_search, y_test_raw)
+
+ split_h = hashlib.sha256()
+ split_h.update(search_idx.tobytes())
+ split_h.update(val_idx.tobytes())
+ split_fp = split_h.hexdigest()[:16]
+
+ provenance = {
+ "input_shape": [1, 28, 28],
+ "pca": False,
+ "raw_inputs": True,
+ "normalization_scope": "search_train_50000_only",
+ "train_mean": round(mean_val, 6),
+ "train_std": round(std_val, 6),
+ "search_samples": 50000,
+ "val_samples": 10000,
+ "test_samples": 10000,
+ "split_seed": split_seed,
+ "split_fingerprint": split_fp,
+ }
+
+ return (
+ x_search_norm, y_search,
+ x_val_norm, y_val,
+ x_test_norm, y_test_raw,
+ nested_subsets,
+ data_fp, provenance
+ )
+
+
+def build_nested_stratified_subsets(
+ y_search: torch.Tensor,
+ subset_sizes: List[int],
+ subset_seed: int = 20260902,
+) -> Dict[int, torch.Tensor]:
+ """
+ Builds nested stratified index tensors: I_2k subset of I_10k subset of I_50k.
+ Uses Hamilton / Largest-Remainder Method for exact subset sizes and nesting.
+ """
+ rng = np.random.RandomState(subset_seed)
+ y_np = y_search.numpy()
+ total_samples = len(y_np)
+ unique_classes, counts = np.unique(y_np, return_counts=True)
+
+ class_indices = {}
+ for c in unique_classes:
+ c_idxs = np.where(y_np == c)[0]
+ rng.shuffle(c_idxs)
+ class_indices[c] = c_idxs
+
+ ordered_subset_sizes = sorted(subset_sizes)
+ nested_subsets: Dict[int, torch.Tensor] = {}
+ selected_per_class: Dict[int, List[int]] = {c: [] for c in unique_classes}
+
+ for size in ordered_subset_sizes:
+ if size == total_samples:
+ nested_subsets[size] = torch.arange(total_samples, dtype=torch.long)
+ continue
+
+ exact_quotas = [size * (counts[i] / total_samples) for i in range(len(unique_classes))]
+ floor_quotas = [int(np.floor(q)) for q in exact_quotas]
+ remainders = [exact_quotas[i] - floor_quotas[i] for i in range(len(unique_classes))]
+
+ needed_extra = size - sum(floor_quotas)
+ ranked_indices = np.argsort(remainders)[::-1]
+ target_counts = list(floor_quotas)
+ for i in range(needed_extra):
+ target_counts[ranked_indices[i]] += 1
+
+ target_subset_idxs = []
+ for i, c in enumerate(unique_classes):
+ target_c_count = target_counts[i]
+ current_list = selected_per_class[c]
+ needed = target_c_count - len(current_list)
+ if needed > 0:
+ available = class_indices[c]
+ added = list(available[len(current_list):len(current_list) + needed])
+ current_list.extend(added)
+ target_subset_idxs.extend(current_list[:target_c_count])
+
+ subset_tensor = torch.tensor(sorted(target_subset_idxs), dtype=torch.long)
+ nested_subsets[size] = subset_tensor
+
+ return nested_subsets
+
+
+# =====================================================================
+# 3. Latent Subspace Transform & Antithetic Swarm Construction
+# =====================================================================
+
+class LatentTransform:
+ def __init__(
+ self,
+ base_model: nn.Module,
+ latent_dim: Union[int, str],
+ device: torch.device,
+ ):
+ self.device = device
+ self.base_params = [p.detach().clone().to(device) for p in base_model.parameters()]
+ self.param_shapes = [p.shape for p in self.base_params]
+ self.param_numels = [p.numel() for p in self.base_params]
+ self.total_dim = sum(self.param_numels)
+
+ # Per-tensor scale calculation: positive scale per parameter tensor
+ tensor_scales = []
+ for p in self.base_params:
+ std_val = float(p.std())
+ scale = max(std_val, 1e-4)
+ scale_tensor = torch.full_like(p, scale)
+ tensor_scales.append(scale_tensor.view(-1))
+ self.scale_vec = torch.cat(tensor_scales).to(device)
+ self.base_vec = torch.cat([p.view(-1) for p in self.base_params]).to(device)
+
+ if isinstance(latent_dim, str) and latent_dim.lower() == "full":
+ self.latent_dim = self.total_dim
+ self.is_full = True
+ else:
+ self.latent_dim = int(latent_dim)
+ self.is_full = (self.latent_dim == self.total_dim)
+
+ if not self.is_full:
+ # Deterministic sparse signed hash mapping
+ j_indices = np.arange(self.total_dim, dtype=np.int64)
+ h1 = ((j_indices + 1) * 2654435761) % (2**32)
+ k_indices = h1 % self.latent_dim
+ h2 = ((j_indices + 1) * 1597334677) % (2**32)
+ signs = np.where((h2 % 2) == 0, 1.0, -1.0)
+
+ # Count normalization to maintain unit variance
+ bin_counts = np.bincount(k_indices, minlength=self.latent_dim)
+ count_per_j = bin_counts[k_indices]
+ scale_per_j = 1.0 / np.sqrt(np.maximum(count_per_j, 1))
+ combined_weights = signs * scale_per_j
+
+ self.k_indices = torch.tensor(k_indices, dtype=torch.long, device=device)
+ self.weights = torch.tensor(combined_weights, dtype=torch.float32, device=device)
+
+ def decode(self, Z: torch.Tensor) -> torch.Tensor:
+ """
+ Transforms latent batch Z (N, d) into full parameter batch (N, D).
+ theta = base_vec + scale_vec * delta
+ """
+ if self.is_full:
+ delta = Z
+ else:
+ delta = Z[:, self.k_indices] * self.weights
+ return self.base_vec + self.scale_vec * delta
+
+ def load_vector_to_model(self, theta_vec: torch.Tensor, model: nn.Module):
+ """Loads a single parameter vector into model parameters in-place."""
+ offset = 0
+ with torch.no_grad():
+ for p, shape, numel in zip(model.parameters(), self.param_shapes, self.param_numels):
+ p.copy_(theta_vec[offset:offset + numel].view(shape))
+ offset += numel
+
+ def init_swarm(self, swarm_size: int, seed: int, init_radius: float = 0.5) -> torch.Tensor:
+ """
+ Initializes particle positions in latent space Z (N, d).
+ Particle 0 is exact base vector (z = 0).
+ For even swarm sizes N, particles 1..N-2 form (N-2)//2 exact pairs, and particle N-1 is zero.
+ """
+ rng = torch.Generator(device="cpu")
+ rng.manual_seed(seed)
+
+ Z = torch.zeros((swarm_size, self.latent_dim), dtype=torch.float32)
+ # Particle 0 stays exact 0
+
+ max_pair_idx = swarm_size - 1 if (swarm_size % 2 != 0) else swarm_size - 2
+
+ idx = 1
+ while idx < max_pair_idx:
+ sample = (torch.rand(self.latent_dim, generator=rng) * 2.0 - 1.0) * init_radius
+ Z[idx] = sample
+ Z[idx + 1] = -sample
+ idx += 2
+
+ return Z.to(self.device)
+
+
+# =====================================================================
+# 4. Device-Resident Latent Adaptive-Moment PSO Engine
+# =====================================================================
+
+def evaluate_latent_batch(
+ Z: torch.Tensor,
+ transform: LatentTransform,
+ model: nn.Module,
+ x_sub_dev: torch.Tensor,
+ y_sub_dev: torch.Tensor,
+ batch_size: int = 1000,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ """
+ Evaluates latent batch Z (N, d) on device-resident (x_sub_dev, y_sub_dev) without host roundtrips.
+ Returns (losses, accuracies) tensors of shape (N,).
+ """
+ N = Z.shape[0]
+ device = Z.device
+ losses = torch.zeros(N, dtype=torch.float32, device=device)
+ accuracies = torch.zeros(N, dtype=torch.float32, device=device)
+
+ loss_fn = nn.CrossEntropyLoss(reduction="sum")
+ num_samples = len(y_sub_dev)
+
+ model.eval()
+ with torch.inference_mode():
+ for i in range(N):
+ theta_vec = transform.decode(Z[i:i+1]).squeeze(0)
+ transform.load_vector_to_model(theta_vec, model)
+
+ total_loss = torch.tensor(0.0, device=device)
+ correct = torch.tensor(0, dtype=torch.long, device=device)
+
+ for b_start in range(0, num_samples, batch_size):
+ xb = x_sub_dev[b_start:b_start + batch_size]
+ yb = y_sub_dev[b_start:b_start + batch_size]
+ logits = model(xb)
+ batch_loss = loss_fn(logits, yb)
+ total_loss += batch_loss
+ preds = logits.argmax(dim=1)
+ correct += (preds == yb).sum()
+
+ losses[i] = total_loss / num_samples
+ accuracies[i] = (correct.float() / num_samples) * 100.0
+
+ return losses, accuracies
+
+
+def run_latent_pso(
+ transform: LatentTransform,
+ base_model: nn.Module,
+ x_search: torch.Tensor,
+ y_search: torch.Tensor,
+ nested_subsets: Dict[int, torch.Tensor],
+ schedule_str: str,
+ epochs: int,
+ swarm_size: int,
+ seed: int,
+ device: torch.device,
+) -> Dict[str, Any]:
+ """
+ Runs device-resident Latent Adaptive-Moment PSO with progressive schedule.
+ Performs full pbest re-evaluation and gbest rebuild ONLY on objective transitions (stages > 0).
+ """
+ sync_device(device)
+ start_time = time.time()
+
+ schedule_stages = []
+ if schedule_str:
+ parts = schedule_str.split(",")
+ for p in parts:
+ sz_str, ep_str = p.split(":")
+ schedule_stages.append((int(sz_str), int(ep_str)))
+
+ if not schedule_stages:
+ schedule_stages = [(50000, epochs)]
+
+ c0 = c1 = 1.49618
+ w = 0.7298
+ blend = 0.06
+ step = 0.5
+ beta1 = 0.9
+ beta2 = 0.999
+ reflective_bound = 3.0
+
+ latent_dim = transform.latent_dim
+ Z = transform.init_swarm(swarm_size=swarm_size, seed=seed)
+ V = torch.zeros((swarm_size, latent_dim), dtype=torch.float32, device=device)
+ M = torch.zeros((swarm_size, latent_dim), dtype=torch.float32, device=device)
+ V_sq = torch.zeros((swarm_size, latent_dim), dtype=torch.float32, device=device)
+
+ # State tracking: P scores start at inf / 0. DO NOT evaluate before stage 0!
+ P = Z.clone()
+ P_loss = torch.full((swarm_size,), float("inf"), dtype=torch.float32, device=device)
+ P_acc = torch.zeros((swarm_size,), dtype=torch.float32, device=device)
+
+ gbest_z = Z[0].clone()
+ gbest_loss = float("inf")
+ gbest_acc = 0.0
+
+ total_queries = 0
+ total_sample_evaluations = 0
+ transition_reevaluation_counts = 0
+
+ rng = torch.Generator(device=device)
+ rng.manual_seed(seed)
+
+ model = make_compact_cnn(seed=41).to(device)
+
+ stage_histories = []
+ t_step = 0
+ epoch_counter = 0
+
+ for stage_idx, (size, stage_epochs) in enumerate(schedule_stages):
+ subset_indices = nested_subsets[size]
+ # Move stage subset to device ONCE per stage
+ x_sub_dev = x_search[subset_indices].to(device)
+ y_sub_dev = y_search[subset_indices].to(device)
+
+ # Objective transition check: ONLY for stages >= 1!
+ if stage_idx > 0:
+ re_losses, re_accs = evaluate_latent_batch(
+ P, transform, model, x_sub_dev, y_sub_dev
+ )
+ P_loss = re_losses
+ P_acc = re_accs
+
+ total_queries += swarm_size
+ total_sample_evaluations += swarm_size * size
+ transition_reevaluation_counts += swarm_size
+
+ min_loss_val = P_loss.min()
+ candidates_mask = (P_loss <= min_loss_val + 1e-7)
+ best_p_idx = int(torch.where(candidates_mask, P_acc, torch.tensor(-1.0, device=device)).argmax().item())
+
+ gbest_z = P[best_p_idx].clone()
+ gbest_loss = float(P_loss[best_p_idx].item())
+ gbest_acc = float(P_acc[best_p_idx].item())
+
+ for ep in range(1, stage_epochs + 1):
+ epoch_counter += 1
+
+ # 1. Evaluate current swarm positions
+ curr_losses, curr_accs = evaluate_latent_batch(
+ Z, transform, model, x_sub_dev, y_sub_dev
+ )
+ total_queries += swarm_size
+ total_sample_evaluations += swarm_size * size
+
+ # 2. Vectorized on-device pbest updates (lexicographical loss primary, acc tie-break)
+ better_loss = curr_losses < P_loss - 1e-7
+ equal_loss = torch.abs(curr_losses - P_loss) <= 1e-7
+ better_acc = curr_accs > P_acc
+ update_mask = better_loss | (equal_loss & better_acc)
+
+ P[update_mask] = Z[update_mask]
+ P_loss[update_mask] = curr_losses[update_mask]
+ P_acc[update_mask] = curr_accs[update_mask]
+
+ # Rebuild gbest from P each epoch on-device
+ min_loss_val = P_loss.min()
+ candidates_mask = (P_loss <= min_loss_val + 1e-7)
+ best_p_idx = int(torch.where(candidates_mask, P_acc, torch.tensor(-1.0, device=device)).argmax().item())
+
+ gbest_z = P[best_p_idx].clone()
+ gbest_loss = float(P_loss[best_p_idx].item())
+ gbest_acc = float(P_acc[best_p_idx].item())
+
+ stage_histories.append({
+ "epoch": epoch_counter,
+ "stage": stage_idx,
+ "subset_size": size,
+ "gbest_loss": round(gbest_loss, 6),
+ "gbest_acc": round(gbest_acc, 4),
+ })
+
+ # 3. Adaptive Moment Movement Step
+ r1 = torch.rand((swarm_size, latent_dim), generator=rng, device=device)
+ r2 = torch.rand((swarm_size, latent_dim), generator=rng, device=device)
+
+ V_raw = w * V + c0 * r1 * (P - Z) + c1 * r2 * (gbest_z.unsqueeze(0) - Z)
+
+ t_step += 1
+ M = beta1 * M + (1 - beta1) * V_raw
+ V_sq = beta2 * V_sq + (1 - beta2) * (V_raw ** 2)
+
+ M_hat = M / (1.0 - beta1 ** t_step)
+ V_sq_hat = V_sq / (1.0 - beta2 ** t_step)
+
+ dir_moment = M_hat / (torch.sqrt(V_sq_hat) + 1e-8)
+ historical_scale = torch.sqrt(torch.mean(V_sq_hat, dim=1, keepdim=True))
+ V_moment = step * dir_moment * historical_scale
+ V_new = (1.0 - blend) * V_raw + blend * V_moment
+
+ Z_new = Z + V_new
+
+ pos_mask = Z_new > reflective_bound
+ neg_mask = Z_new < -reflective_bound
+
+ Z_new[pos_mask] = 2.0 * reflective_bound - Z_new[pos_mask]
+ V_new[pos_mask] = -V_new[pos_mask]
+
+ Z_new[neg_mask] = -2.0 * reflective_bound - Z_new[neg_mask]
+ V_new[neg_mask] = -V_new[neg_mask]
+
+ Z_new = torch.clamp(Z_new, -reflective_bound, reflective_bound)
+
+ Z = Z_new
+ V = V_new
+
+ if epoch_counter >= epochs:
+ break
+ if epoch_counter >= epochs:
+ break
+
+ sync_device(device)
+ wall_time = time.time() - start_time
+
+ return {
+ "gbest_z": gbest_z,
+ "gbest_loss": gbest_loss,
+ "gbest_acc": gbest_acc,
+ "final_P": P,
+ "wall_time_sec": round(wall_time, 4),
+ "total_queries": total_queries,
+ "total_sample_evaluations": total_sample_evaluations,
+ "transition_reevaluation_counts": transition_reevaluation_counts,
+ "stage_histories": stage_histories,
+ }
+
+
+# =====================================================================
+# 5. Evaluation Metrics (NLL, Brier, ECE, Margin, Disagreement)
+# =====================================================================
+
+def evaluate_probabilistic_metrics(
+ prob_matrix: torch.Tensor,
+ y_true: torch.Tensor,
+) -> Dict[str, float]:
+ """
+ Computes accuracy, NLL, Brier score, 15-bin ECE, and probability margin.
+ """
+ N, C = prob_matrix.shape
+ probs = prob_matrix.cpu().numpy()
+ labels = y_true.cpu().numpy()
+
+ preds = probs.argmax(axis=1)
+ acc = float((preds == labels).mean()) * 100.0
+
+ eps = 1e-12
+ clipped_probs = np.clip(probs, eps, 1.0 - eps)
+ nll = -float(np.log(clipped_probs[np.arange(N), labels]).mean())
+
+ y_onehot = np.zeros((N, C), dtype=np.float32)
+ y_onehot[np.arange(N), labels] = 1.0
+ brier = float(np.mean(np.sum((probs - y_onehot) ** 2, axis=1)))
+
+ n_bins = 15
+ bin_boundaries = np.linspace(0.0, 1.0, n_bins + 1)
+ confidences = probs.max(axis=1)
+ ece = 0.0
+
+ for i in range(n_bins):
+ bin_lower = bin_boundaries[i]
+ bin_upper = bin_boundaries[i + 1]
+ in_bin = (confidences > bin_lower) & (confidences <= bin_upper) if i > 0 else (confidences >= bin_lower) & (confidences <= bin_upper)
+ prop_in_bin = in_bin.mean()
+ if prop_in_bin > 0:
+ accuracy_in_bin = (preds[in_bin] == labels[in_bin]).mean()
+ avg_confidence_in_bin = confidences[in_bin].mean()
+ ece += np.abs(accuracy_in_bin - avg_confidence_in_bin) * prop_in_bin
+
+ sorted_probs = np.sort(probs, axis=1)[:, ::-1]
+ margins = sorted_probs[:, 0] - sorted_probs[:, 1]
+ margin_mean = float(margins.mean())
+
+ return {
+ "accuracy": round(acc, 4),
+ "nll": round(nll, 6),
+ "brier": round(brier, 6),
+ "ece": round(float(ece), 6),
+ "margin": round(margin_mean, 6),
+ }
+
+
+def compute_pairwise_disagreement(model_preds_list: List[np.ndarray]) -> float:
+ num_models = len(model_preds_list)
+ if num_models < 2:
+ return 0.0
+
+ disagreements = []
+ for i in range(num_models):
+ for j in range(i + 1, num_models):
+ dis = float((model_preds_list[i] != model_preds_list[j]).mean())
+ disagreements.append(dis)
+
+ return round(float(np.mean(disagreements)), 6)
+
+
+def select_diverse_candidates(
+ candidates: List[Dict[str, Any]],
+ *,
+ max_size: int = 5,
+ accuracy_window: float = 2.0,
+) -> List[Dict[str, Any]]:
+ if not candidates:
+ raise ValueError("candidates must not be empty")
+ if max_size <= 0:
+ raise ValueError("max_size must be positive")
+ if accuracy_window < 0.0:
+ raise ValueError("accuracy_window must be nonnegative")
+
+ ranked = sorted(candidates, key=lambda c: (c["val_loss"], -c["val_acc"]))
+ accuracy_threshold = ranked[0]["val_acc"] - accuracy_window
+ eligible = [c for c in ranked if c["val_acc"] >= accuracy_threshold]
+
+ selected = [eligible[0]]
+ selected_keys = {(eligible[0]["seed"], eligible[0]["particle_idx"])}
+ predictions = {
+ (candidate["seed"], candidate["particle_idx"]):
+ candidate["val_probs"].argmax(dim=1).cpu().numpy()
+ for candidate in eligible
+ }
+
+ while len(selected) < min(max_size, len(eligible)):
+ best_next = None
+ best_key = None
+ max_disagreement = -1.0
+ best_val_loss = float("inf")
+
+ for candidate in eligible:
+ candidate_key = (candidate["seed"], candidate["particle_idx"])
+ if candidate_key in selected_keys:
+ continue
+ candidate_predictions = predictions[candidate_key]
+ mean_disagreement = float(np.mean([
+ (candidate_predictions - predictions[
+ (member["seed"], member["particle_idx"])
+ ] != 0).mean()
+ for member in selected
+ ]))
+ if (
+ mean_disagreement > max_disagreement + 1e-7
+ or (
+ abs(mean_disagreement - max_disagreement) <= 1e-7
+ and candidate["val_loss"] < best_val_loss
+ )
+ ):
+ best_next = candidate
+ best_key = candidate_key
+ max_disagreement = mean_disagreement
+ best_val_loss = candidate["val_loss"]
+
+ if best_next is None or best_key is None:
+ break
+ selected.append(best_next)
+ selected_keys.add(best_key)
+
+ return selected
+
+
+# =====================================================================
+# 6. Full Experiment Pipeline & CLI Runner
+# =====================================================================
+
+def validate_cli_args(args: argparse.Namespace):
+ if args.pilot_epochs <= 0 or args.confirmation_epochs <= 0:
+ raise ValueError("Pilot and confirmation epochs must be positive integers.")
+ if args.pilot_particles <= 0 or args.confirmation_particles <= 0:
+ raise ValueError("Pilot and confirmation particles must be positive integers.")
+ if any(s < 0 for s in args.seeds):
+ raise ValueError("Seeds must be non-negative integers.")
+ if len(args.seeds) != len(set(args.seeds)):
+ raise ValueError("Confirmation seeds must be unique.")
+
+ max_d = 9098
+ for d_str in args.dimensions:
+ if d_str.lower() != "full":
+ try:
+ d_val = int(d_str)
+ if d_val <= 0 or d_val > max_d:
+ raise ValueError(f"Latent dimension {d_val} must be in range [1, {max_d}].")
+ except ValueError:
+ raise ValueError(f"Invalid dimension specifier: {d_str}")
+
+ if args.confirmation_schedule:
+ stages = args.confirmation_schedule.split(",")
+ total_sched_epochs = 0
+ known_sizes = {2000, 10000, 50000}
+ for s in stages:
+ sz_str, ep_str = s.split(":")
+ sz, ep = int(sz_str), int(ep_str)
+ if sz not in known_sizes:
+ raise ValueError(f"Unknown schedule subset size {sz}; known sizes are {known_sizes}.")
+ if ep <= 0:
+ raise ValueError(f"Schedule epochs must be positive; got {ep}.")
+ total_sched_epochs += ep
+ if total_sched_epochs != args.confirmation_epochs:
+ raise ValueError(
+ f"Schedule epoch sum ({total_sched_epochs}) must equal confirmation_epochs ({args.confirmation_epochs})."
+ )
+
+
+def run_deep_pso_study(args: argparse.Namespace) -> Dict[str, Any]:
+ validate_cli_args(args)
+
+ device = resolve_execution_device(args.device)
+ print(f"=== MNIST Deep PSO Methods Study (Protocol {PROTOCOL_VERSION}) ===")
+ print(f"Device: {device}")
+
+ # Data preparation
+ (
+ x_search, y_search,
+ x_val, y_val,
+ x_test, y_test,
+ nested_subsets,
+ data_fp, provenance
+ ) = prepare_mnist_v5_data(split_seed=args.split_seed)
+
+ base_model = make_compact_cnn(seed=41).to(device)
+ base_fp = compute_model_fingerprint(base_model)
+ hardware_prov = get_hardware_provenance(device)
+
+ failure_record: Optional[str] = None
+
+ # Pilot Phase: Validation-only selection of latent dimension
+ print("\n--- Pilot Phase (Dimension Selection on 10k Validation Set) ---")
+ pilot_results = []
+ best_pilot_dim = None
+ best_pilot_val_loss = float("inf")
+ best_pilot_val_acc = 0.0
+
+ dimensions = args.dimensions
+
+ for dim_str in dimensions:
+ print(f"Running Pilot: dim={dim_str}, seed={args.pilot_seed}, particles={args.pilot_particles}, epochs={args.pilot_epochs}")
+ transform = LatentTransform(base_model, latent_dim=dim_str, device=device)
+ res = run_latent_pso(
+ transform=transform,
+ base_model=base_model,
+ x_search=x_search,
+ y_search=y_search,
+ nested_subsets=nested_subsets,
+ schedule_str=f"2000:{args.pilot_epochs}",
+ epochs=args.pilot_epochs,
+ swarm_size=args.pilot_particles,
+ seed=args.pilot_seed,
+ device=device,
+ )
+
+ model = make_compact_cnn(seed=41).to(device)
+ transform.load_vector_to_model(transform.decode(res["gbest_z"].unsqueeze(0)).squeeze(0), model)
+
+ probs_val = get_model_probabilities(model, x_val, device)
+ val_metrics = evaluate_probabilistic_metrics(probs_val, y_val)
+
+ pilot_record = {
+ "dimension": str(dim_str),
+ "val_loss": val_metrics["nll"],
+ "val_acc": val_metrics["accuracy"],
+ "wall_time_sec": res["wall_time_sec"],
+ "queries": res["total_queries"],
+ "sample_evaluations": res["total_sample_evaluations"],
+ }
+ pilot_results.append(pilot_record)
+ print(f"Pilot dim={dim_str} -> Val Loss: {val_metrics['nll']:.6f}, Val Acc: {val_metrics['accuracy']:.2f}%")
+
+ if (val_metrics["nll"] < best_pilot_val_loss - 1e-7) or (abs(val_metrics["nll"] - best_pilot_val_loss) <= 1e-7 and val_metrics["accuracy"] > best_pilot_val_acc):
+ best_pilot_val_loss = val_metrics["nll"]
+ best_pilot_val_acc = val_metrics["accuracy"]
+ best_pilot_dim = dim_str
+
+ print(f"\nSelected Pilot Dimension: {best_pilot_dim} (Val Loss: {best_pilot_val_loss:.6f}, Val Acc: {best_pilot_val_acc:.2f}%)")
+
+ # Confirmation Phase: Run multi-seed progressive PSO on selected dimension
+ print(f"\n--- Confirmation Phase (Dimension={best_pilot_dim}, Seeds={args.seeds}) ---")
+ confirmation_runs = []
+ val_candidate_pool = []
+
+ conf_transform = LatentTransform(base_model, latent_dim=best_pilot_dim, device=device)
+
+ for c_seed in args.seeds:
+ print(f"Running Confirmation: seed={c_seed}, particles={args.confirmation_particles}, epochs={args.confirmation_epochs}, schedule={args.confirmation_schedule}")
+ res = run_latent_pso(
+ transform=conf_transform,
+ base_model=base_model,
+ x_search=x_search,
+ y_search=y_search,
+ nested_subsets=nested_subsets,
+ schedule_str=args.confirmation_schedule,
+ epochs=args.confirmation_epochs,
+ swarm_size=args.confirmation_particles,
+ seed=c_seed,
+ device=device,
+ )
+
+ # Evaluate EVERY particle's pbest on the 10k VALIDATION set
+ P_final = res["final_P"]
+ run_best_val_loss = float("inf")
+ run_best_val_acc = 0.0
+
+ for p_idx in range(len(P_final)):
+ p_z = P_final[p_idx]
+ cand_model = make_compact_cnn(seed=41).to(device)
+ conf_transform.load_vector_to_model(conf_transform.decode(p_z.unsqueeze(0)).squeeze(0), cand_model)
+ probs_val = get_model_probabilities(cand_model, x_val, device)
+ val_metrics = evaluate_probabilistic_metrics(probs_val, y_val)
+
+ cand_rec = {
+ "seed": c_seed,
+ "particle_idx": p_idx,
+ "val_loss": val_metrics["nll"],
+ "val_acc": val_metrics["accuracy"],
+ "val_probs": probs_val,
+ "latent_z": p_z,
+ }
+ val_candidate_pool.append(cand_rec)
+
+ if (val_metrics["nll"] < run_best_val_loss - 1e-7) or (abs(val_metrics["nll"] - run_best_val_loss) <= 1e-7 and val_metrics["accuracy"] > run_best_val_acc):
+ run_best_val_loss = val_metrics["nll"]
+ run_best_val_acc = val_metrics["accuracy"]
+
+ conf_record = {
+ "seed": c_seed,
+ "val_loss": run_best_val_loss,
+ "val_acc": run_best_val_acc,
+ "wall_time_sec": res["wall_time_sec"],
+ "queries": res["total_queries"],
+ "sample_evaluations": res["total_sample_evaluations"],
+ "transition_reevaluations": res["transition_reevaluation_counts"],
+ "stage_histories": res["stage_histories"],
+ }
+ confirmation_runs.append(conf_record)
+
+ print(f"Confirmation seed={c_seed} -> Best Val Loss: {run_best_val_loss:.6f}, Best Val Acc: {run_best_val_acc:.2f}%")
+
+ # Selection on Validation ONLY:
+ # 1. Single Final Model (lowest val NLL, then highest val Acc)
+ val_candidate_pool.sort(key=lambda c: (c["val_loss"], -c["val_acc"]))
+ best_single_candidate = val_candidate_pool[0]
+
+ # 2. Predeclared validation-performing, prediction-diverse Top-5 Ensemble
+ top_ensemble_candidates = select_diverse_candidates(val_candidate_pool)
+
+ # Official 10k Test Set Evaluation (EXACTLY ONCE PER ENDPOINT)
+ print("\n--- Final Official 10k Test Evaluation ---")
+
+ # Single Final Model Test Evaluation
+ single_model = make_compact_cnn(seed=41).to(device)
+ conf_transform.load_vector_to_model(conf_transform.decode(best_single_candidate["latent_z"].unsqueeze(0)).squeeze(0), single_model)
+
+ single_test_probs = get_model_probabilities(single_model, x_test, device)
+ single_test_metrics = evaluate_probabilistic_metrics(single_test_probs, y_test)
+ single_model_fp = compute_model_fingerprint(single_model)
+
+ print(f"Final Single Model (Seed {best_single_candidate['seed']}, Part {best_single_candidate['particle_idx']}) -> Test Acc: {single_test_metrics['accuracy']:.2f}%, Test NLL: {single_test_metrics['nll']:.6f}")
+
+ # Top Ensemble Test Evaluation
+ ensemble_test_probs_list = []
+ ensemble_preds_list = []
+
+ for cand in top_ensemble_candidates:
+ cand_model = make_compact_cnn(seed=41).to(device)
+ conf_transform.load_vector_to_model(conf_transform.decode(cand["latent_z"].unsqueeze(0)).squeeze(0), cand_model)
+ t_probs = get_model_probabilities(cand_model, x_test, device)
+ ensemble_test_probs_list.append(t_probs)
+ ensemble_preds_list.append(t_probs.argmax(dim=1).cpu().numpy())
+
+ ensemble_mean_probs = torch.stack(ensemble_test_probs_list).mean(dim=0)
+ ensemble_test_metrics = evaluate_probabilistic_metrics(ensemble_mean_probs, y_test)
+ ensemble_disagreement = compute_pairwise_disagreement(ensemble_preds_list)
+
+ print(f"Top-{len(top_ensemble_candidates)} Ensemble -> Test Acc: {ensemble_test_metrics['accuracy']:.2f}%, Test NLL: {ensemble_test_metrics['nll']:.6f}, Disagreement: {ensemble_disagreement:.6f}")
+ ensemble_val_probs = torch.stack(
+ [cand["val_probs"] for cand in top_ensemble_candidates]
+ ).mean(dim=0)
+ ensemble_val_metrics = evaluate_probabilistic_metrics(
+ ensemble_val_probs, y_val
+ )
+ ensemble_val_disagreement = compute_pairwise_disagreement(
+ [
+ cand["val_probs"].argmax(dim=1).cpu().numpy()
+ for cand in top_ensemble_candidates
+ ]
+ )
+
+
+ total_wall_time = sum(c["wall_time_sec"] for c in confirmation_runs) + sum(p["wall_time_sec"] for p in pilot_results)
+ total_queries_all = sum(c["queries"] for c in confirmation_runs) + sum(p["queries"] for p in pilot_results)
+ total_samples_all = sum(c["sample_evaluations"] for c in confirmation_runs) + sum(p["sample_evaluations"] for p in pilot_results)
+
+ final_payload = {
+ "protocol_version": PROTOCOL_VERSION,
+ "pso_version": pso_version,
+ "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+ "completed": True,
+ "hardware_provenance": hardware_prov,
+ "data_provenance": provenance,
+ "data_fingerprint": data_fp,
+ "base_model_fingerprint": base_fp,
+ "configuration": {
+ "base_model_seed": 41,
+ "split_seed": args.split_seed,
+ "pilot_seed": args.pilot_seed,
+ "pilot_dimensions": [str(dim) for dim in args.dimensions],
+ "pilot_particles": args.pilot_particles,
+ "pilot_epochs": args.pilot_epochs,
+ "confirmation_seeds": args.seeds,
+ "confirmation_particles": args.confirmation_particles,
+ "confirmation_epochs": args.confirmation_epochs,
+ "confirmation_schedule": args.confirmation_schedule,
+ "fitness_objective": "cross_entropy_loss_primary_accuracy_tiebreak",
+ "parameterization": {
+ "layer_scale": "per_parameter_tensor_std_floor_1e-4",
+ "subspace": "deterministic_sparse_signed_hash_count_normalized",
+ "initialization": "exact_base_plus_antithetic",
+ "initial_radius": 0.5,
+ "reflective_bound": 3.0,
+ },
+ "movement": {
+ "name": "latent_adaptive_moment_pso",
+ "c0": 1.49618,
+ "c1": 1.49618,
+ "w": 0.7298,
+ "moment_blend": 0.06,
+ "moment_step_size": 0.5,
+ "moment_beta1": 0.9,
+ "moment_beta2": 0.999,
+ },
+ "objective_transition": "reevaluate_all_pbests_then_rebuild_gbest",
+ "validation_selection": {
+ "single": "lowest_nll_then_highest_accuracy",
+ "ensemble": "within_2_accuracy_points_then_greedy_disagreement",
+ "ensemble_size": 5,
+ },
+ "fitness_batch_size": 1000,
+ "ece_bins": 15,
+ },
+ "pilot_phase": {
+ "selected_dimension": str(best_pilot_dim),
+ "results": pilot_results,
+ },
+ "confirmation_phase": {
+ "runs": [
+ {
+ "seed": r["seed"],
+ "val_loss": r["val_loss"],
+ "val_acc": r["val_acc"],
+ "wall_time_sec": r["wall_time_sec"],
+ "queries": r["queries"],
+ "sample_evaluations": r["sample_evaluations"],
+ "transition_reevaluations": r["transition_reevaluations"],
+ "stage_histories": r["stage_histories"],
+ }
+ for r in confirmation_runs
+ ],
+ "validation_summary": {
+ "best_pbest_nll": calc_stats(
+ [run["val_loss"] for run in confirmation_runs]
+ ),
+ "best_pbest_accuracy": calc_stats(
+ [run["val_acc"] for run in confirmation_runs]
+ ),
+ "wall_time_sec": calc_stats(
+ [run["wall_time_sec"] for run in confirmation_runs]
+ ),
+ },
+ },
+ "final_endpoints": {
+ "single_model": {
+ "selected_seed": best_single_candidate["seed"],
+ "selected_particle_idx": best_single_candidate["particle_idx"],
+ "model_fingerprint": single_model_fp,
+ "val_loss": best_single_candidate["val_loss"],
+ "val_acc": best_single_candidate["val_acc"],
+ "selection_rule": "lowest_validation_nll_then_highest_accuracy",
+ "test_accuracy": single_test_metrics["accuracy"],
+ "test_nll": single_test_metrics["nll"],
+ "test_brier": single_test_metrics["brier"],
+ "test_ece": single_test_metrics["ece"],
+ "test_margin": single_test_metrics["margin"],
+ },
+ "ensemble": {
+ "ensemble_size": len(top_ensemble_candidates),
+ "members": [
+ {
+ "seed": cand["seed"],
+ "particle_idx": cand["particle_idx"],
+ "val_loss": cand["val_loss"],
+ "val_acc": cand["val_acc"],
+ }
+ for cand in top_ensemble_candidates
+ ],
+ "validation_accuracy": ensemble_val_metrics["accuracy"],
+ "validation_nll": ensemble_val_metrics["nll"],
+ "validation_brier": ensemble_val_metrics["brier"],
+ "validation_ece": ensemble_val_metrics["ece"],
+ "validation_margin": ensemble_val_metrics["margin"],
+ "validation_pairwise_disagreement": ensemble_val_disagreement,
+ "test_accuracy": ensemble_test_metrics["accuracy"],
+ "test_nll": ensemble_test_metrics["nll"],
+ "test_brier": ensemble_test_metrics["brier"],
+ "test_ece": ensemble_test_metrics["ece"],
+ "test_margin": ensemble_test_metrics["margin"],
+ "pairwise_disagreement": ensemble_disagreement,
+ },
+ },
+ "accounting": {
+ "total_wall_time_sec": round(total_wall_time, 4),
+ "total_queries": total_queries_all,
+ "total_sample_evaluations": total_samples_all,
+ "scope": (
+ "pilot_and_confirmation_training_objectives_including_"
+ "transition_reevaluations; excludes validation and test"
+ ),
+ },
+ "failure_record": failure_record,
+ }
+
+ # Save atomic JSON
+ json_path = Path(args.json_path)
+ save_json_atomic(final_payload, json_path)
+ print(f"Saved atomic JSON to {json_path}")
+
+ # Save CSV
+ csv_path = Path(args.csv_path)
+ save_csv_summary(final_payload, csv_path)
+ print(f"Saved CSV summary to {csv_path}")
+
+ # Save PNG plot
+ plot_path = Path(args.plot_path)
+ generate_study_plots(final_payload, plot_path)
+ print(f"Saved PNG plot to {plot_path}")
+
+ return final_payload
+
+
+def get_model_probabilities(model: nn.Module, x_data: torch.Tensor, device: torch.device, batch_size: int = 1000) -> torch.Tensor:
+ model.eval()
+ prob_list = []
+ num_samples = len(x_data)
+ with torch.inference_mode():
+ for b_start in range(0, num_samples, batch_size):
+ xb = x_data[b_start:b_start + batch_size].to(device)
+ logits = model(xb)
+ probs = torch.softmax(logits, dim=1)
+ prob_list.append(probs)
+ return torch.cat(prob_list, dim=0)
+
+
+def save_csv_summary(payload: Dict[str, Any], csv_path: Path):
+ csv_path.parent.mkdir(parents=True, exist_ok=True)
+ with open(csv_path, "w", newline="", encoding="utf-8") as f:
+ writer = csv.writer(f)
+ writer.writerow(["section", "metric", "value"])
+ writer.writerow(["protocol", "version", payload["protocol_version"]])
+
+ pilot = payload["pilot_phase"]
+ writer.writerow(["pilot", "selected_dimension", pilot["selected_dimension"]])
+
+ single = payload["final_endpoints"]["single_model"]
+ writer.writerow(["single_model", "test_accuracy", single["test_accuracy"]])
+ writer.writerow(["single_model", "test_nll", single["test_nll"]])
+ writer.writerow(["single_model", "test_brier", single["test_brier"]])
+ writer.writerow(["single_model", "test_ece", single["test_ece"]])
+
+ ens = payload["final_endpoints"]["ensemble"]
+ writer.writerow(["ensemble", "test_accuracy", ens["test_accuracy"]])
+ writer.writerow(["ensemble", "test_nll", ens["test_nll"]])
+ writer.writerow(["ensemble", "pairwise_disagreement", ens["pairwise_disagreement"]])
+
+
+def generate_study_plots(payload: Dict[str, Any], plot_path: Path):
+ plot_path.parent.mkdir(parents=True, exist_ok=True)
+ fig, axes = plt.subplots(1, 3, figsize=(18, 5))
+
+ # Panel 1: Pilot Dimension Selection
+ pilot_results = payload["pilot_phase"]["results"]
+ dims = [r["dimension"] for r in pilot_results]
+ val_losses = [r["val_loss"] for r in pilot_results]
+ val_accs = [r["val_acc"] for r in pilot_results]
+
+ ax1 = axes[0]
+ ax1_twin = ax1.twinx()
+ b1 = ax1.bar(np.arange(len(dims)) - 0.2, val_losses, width=0.4, color="#56B4E9", label="Val NLL")
+ b2 = ax1_twin.bar(np.arange(len(dims)) + 0.2, val_accs, width=0.4, color="#009E73", label="Val Acc (%)")
+ ax1.set_xticks(range(len(dims)))
+ ax1.set_xticklabels(dims)
+ ax1.set_xlabel("Latent Dimension")
+ ax1.set_ylabel("Validation NLL")
+ ax1_twin.set_ylabel("Validation Accuracy (%)")
+ ax1.set_title("Pilot Dimension Selection")
+
+ # Panel 2: Confirmation Training Histories
+ ax2 = axes[1]
+ conf_runs = payload["confirmation_phase"]["runs"]
+ for run in conf_runs:
+ hist = run["stage_histories"]
+ epochs = [h["epoch"] for h in hist]
+ losses = [h["gbest_loss"] for h in hist]
+ ax2.plot(epochs, losses, label=f"Seed {run['seed']}")
+ ax2.set_xlabel("Epoch")
+ ax2.set_ylabel("Gbest CE Loss")
+ ax2.set_title("Confirmation Stage Training Histories")
+ ax2.legend()
+ ax2.grid(True, linestyle="--", alpha=0.5)
+
+ # Panel 3: Final Endpoint Comparison
+ ax3 = axes[2]
+ single_acc = payload["final_endpoints"]["single_model"]["test_accuracy"]
+ ens_acc = payload["final_endpoints"]["ensemble"]["test_accuracy"]
+ single_nll = payload["final_endpoints"]["single_model"]["test_nll"]
+ ens_nll = payload["final_endpoints"]["ensemble"]["test_nll"]
+
+ x_labels = ["Single Model", "Top-5 Ensemble"]
+ accs = [single_acc, ens_acc]
+ nlls = [single_nll, ens_nll]
+
+ ax3_twin = ax3.twinx()
+ ax3.bar(np.arange(2) - 0.15, accs, width=0.3, color="#CC79A7", label="Test Acc (%)")
+ ax3_twin.bar(np.arange(2) + 0.15, nlls, width=0.3, color="#D55E00", label="Test NLL")
+ ax3.set_xticks(range(2))
+ ax3.set_xticklabels(x_labels)
+ ax3.set_ylabel("Test Accuracy (%)")
+ ax3_twin.set_ylabel("Test NLL")
+ ax3.set_title("Final Official Test Endpoints")
+
+ plt.tight_layout()
+ plt.savefig(plot_path, dpi=300)
+ plt.close(fig)
+
+
+def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(description="MNIST Deep PSO Methods Study (V5)")
+ parser.add_argument("--pilot-epochs", type=int, default=160)
+ parser.add_argument("--pilot-particles", type=int, default=30)
+ parser.add_argument("--pilot-seed", type=int, default=91)
+ parser.add_argument("--split-seed", type=int, default=20260902)
+ parser.add_argument("--confirmation-epochs", type=int, default=600)
+ parser.add_argument("--confirmation-particles", type=int, default=60)
+ parser.add_argument("--confirmation-schedule", type=str, default="2000:420,10000:135,50000:45")
+ parser.add_argument("--seeds", nargs="+", type=int, default=[101, 102, 103])
+ parser.add_argument("--dimensions", nargs="+", type=str, default=["290", "1024", "4096", "full"])
+ parser.add_argument("--device", type=str, default=None)
+ parser.add_argument("--json-path", type=str, default="benchmark_results/pso_v5_deep_methods.json")
+ parser.add_argument("--csv-path", type=str, default="benchmark_results/pso_v5_deep_methods.csv")
+ parser.add_argument("--plot-path", type=str, default="history_plt/pso_v5_deep_methods.png")
+ return parser
+
+
+if __name__ == "__main__":
+ parser = build_parser()
+ args = parser.parse_args()
+ run_deep_pso_study(args)
diff --git a/test/deep_pso_v6.py b/test/deep_pso_v6.py
new file mode 100644
index 0000000..b6b6ef4
--- /dev/null
+++ b/test/deep_pso_v6.py
@@ -0,0 +1,1464 @@
+"""
+MNIST PSO V6 Study - Phase A & B: Geometry Ablation & Root-Cause Isolation.
+
+Protocol Version: MNIST-PSO-RAW-V6 1.0.0
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+from dataclasses import dataclass, asdict
+import hashlib
+import math
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+from sklearn.model_selection import train_test_split
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+# Ensure test directory and repo root are in Python path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+from benchmark_suite import (
+ calc_stats,
+ compute_model_fingerprint,
+ get_hardware_provenance,
+ resolve_execution_device,
+ save_json_atomic,
+ sync_device,
+)
+from deep_pso_methods import (
+ make_compact_cnn,
+ build_nested_stratified_subsets,
+ evaluate_probabilistic_metrics,
+ get_model_probabilities,
+)
+from pso import __version__ as pso_version
+
+PROTOCOL_VERSION = "MNIST-PSO-RAW-V6 1.0.0"
+
+
+# =====================================================================
+# 1. Dataset Preparation: Train-Only Search/Validation (No Test Split)
+# =====================================================================
+
+def prepare_mnist_v6_data(
+ split_seed: int = 20260902,
+ cache_dir: Optional[Path] = None,
+) -> Tuple[
+ torch.Tensor, torch.Tensor,
+ torch.Tensor, torch.Tensor,
+ Dict[int, torch.Tensor],
+ str, Dict[str, Any]
+]:
+ """
+ Train-only MNIST data preparation using exclusively MNIST(train=True).
+ Never constructs MNIST(train=False).
+ Preserves exact V5 split seed (20260902), search-only normalization,
+ and nested 2k/10k/50k index stratification.
+ """
+ from torchvision.datasets import MNIST
+
+ if cache_dir is None:
+ cache_dir = Path("result/cache")
+ cache_dir.mkdir(parents=True, exist_ok=True)
+
+ # Strictly train=True. Never construct train=False.
+ raw_train = MNIST(root=str(cache_dir), train=True, download=True)
+
+ x_train_raw = raw_train.data.float() / 255.0 # (60000, 28, 28)
+ y_train_raw = raw_train.targets.long()
+
+ # Stratified split: 50,000 search set and 10,000 validation set
+ indices = np.arange(len(y_train_raw))
+ search_idx, val_idx = train_test_split(
+ indices,
+ train_size=50000,
+ test_size=10000,
+ stratify=y_train_raw.numpy(),
+ random_state=split_seed,
+ )
+
+ x_search_raw = x_train_raw[search_idx]
+ y_search = y_train_raw[search_idx]
+ x_val_raw = x_train_raw[val_idx]
+ y_val = y_train_raw[val_idx]
+
+ # Fit mean and std on 50k search subset ONLY
+ mean_val = float(x_search_raw.mean())
+ std_val = float(x_search_raw.std())
+
+ x_search_norm = ((x_search_raw - mean_val) / std_val).unsqueeze(1) # (50000, 1, 28, 28)
+ x_val_norm = ((x_val_raw - mean_val) / std_val).unsqueeze(1) # (10000, 1, 28, 28)
+
+ # Nested stratified subsets inside 50k search set: 2k inside 10k inside 50k
+ nested_subsets = build_nested_stratified_subsets(
+ y_search=y_search,
+ subset_sizes=[2000, 10000, 50000],
+ subset_seed=split_seed,
+ )
+
+ # Data fingerprint over search and validation splits (no test split)
+ h = hashlib.sha256()
+ for t in (x_search_norm, x_val_norm, y_search, y_val):
+ h.update(t.detach().cpu().numpy().tobytes())
+ data_fp = h.hexdigest()[:16]
+
+ split_h = hashlib.sha256()
+ split_h.update(search_idx.tobytes())
+ split_h.update(val_idx.tobytes())
+ split_fp = split_h.hexdigest()[:16]
+
+ provenance = {
+ "input_shape": [1, 28, 28],
+ "pca": False,
+ "raw_inputs": True,
+ "normalization_scope": "search_train_50000_only",
+ "train_mean": round(mean_val, 6),
+ "train_std": round(std_val, 6),
+ "search_samples": 50000,
+ "val_samples": 10000,
+ "test_samples": 0,
+ "official_test_evaluations": 0,
+ "split_seed": split_seed,
+ "split_fingerprint": split_fp,
+ }
+
+ return (
+ x_search_norm, y_search,
+ x_val_norm, y_val,
+ nested_subsets,
+ data_fp, provenance
+ )
+
+
+# =====================================================================
+# 2. Immutable Geometry Configuration & Protocol Table (G0 - G8)
+# =====================================================================
+
+@dataclass(frozen=True)
+class V6GeometryConfig:
+ """
+ Immutable geometry configuration specifying coordinate scales,
+ initial position / velocity distributions, mutation, and bounds.
+ """
+ config_id: str
+ scale_type: str = "per_tensor_sd" # "per_tensor_sd", "global_rms", "identity", "optimizer_default"
+ init_position_mode: str = "antithetic" # "antithetic", "independent"
+ position_radius: float = 0.5 # initial position radius
+ initial_velocity_radius: float = 0.0 # 0.0 for zero launch velocity, >0 for U(-r, r)
+ mutation_prob: float = 0.0 # 0.0 or 0.02
+ reset_velocity_radius: float = 0.02 # velocity radius sampled upon mutation
+ reflective_bound: float = 3.0 # reflective box half-width (e.g. 3.0 or 6.0)
+ projection_seed: Optional[int] = None # seed for sparse signed-hash subspace projection
+ latent_dim: Union[int, str] = "full" # "full" or integer dimension (e.g. 290, 1024)
+ description: str = ""
+
+
+def get_v6_geometry_table() -> Dict[str, V6GeometryConfig]:
+ """
+ Returns the complete, approved Phase B geometry configuration table (G0 - G8).
+ """
+ return {
+ "G0": V6GeometryConfig(
+ config_id="G0",
+ scale_type="per_tensor_sd",
+ init_position_mode="antithetic",
+ position_radius=0.5,
+ initial_velocity_radius=0.0,
+ mutation_prob=0.0,
+ reflective_bound=3.0,
+ description="exact V5 control",
+ ),
+ "G1": V6GeometryConfig(
+ config_id="G1",
+ scale_type="global_rms",
+ init_position_mode="antithetic",
+ position_radius=0.5,
+ initial_velocity_radius=0.0,
+ mutation_prob=0.0,
+ reflective_bound=3.0,
+ description="isolate anisotropic per-tensor scaling",
+ ),
+ "G2": V6GeometryConfig(
+ config_id="G2",
+ scale_type="per_tensor_sd",
+ init_position_mode="antithetic",
+ position_radius=0.5,
+ initial_velocity_radius=0.5,
+ mutation_prob=0.0,
+ reflective_bound=3.0,
+ description="isolate nonzero launch velocity",
+ ),
+ "G3": V6GeometryConfig(
+ config_id="G3",
+ scale_type="per_tensor_sd",
+ init_position_mode="antithetic",
+ position_radius=0.5,
+ initial_velocity_radius=0.0,
+ mutation_prob=0.02,
+ reset_velocity_radius=0.02,
+ reflective_bound=3.0,
+ description="isolate mutation",
+ ),
+ "G4": V6GeometryConfig(
+ config_id="G4",
+ scale_type="per_tensor_sd",
+ init_position_mode="antithetic",
+ position_radius=0.5,
+ initial_velocity_radius=0.5,
+ mutation_prob=0.02,
+ reset_velocity_radius=0.02,
+ reflective_bound=3.0,
+ description="velocity x mutation interaction",
+ ),
+ "G5": V6GeometryConfig(
+ config_id="G5",
+ scale_type="per_tensor_sd",
+ init_position_mode="antithetic",
+ position_radius=0.5,
+ initial_velocity_radius=0.5,
+ mutation_prob=0.02,
+ reset_velocity_radius=0.02,
+ reflective_bound=6.0,
+ description="test sufficient bound expansion",
+ ),
+ "G6": V6GeometryConfig(
+ config_id="G6",
+ scale_type="per_tensor_sd",
+ init_position_mode="antithetic",
+ position_radius=1.5,
+ initial_velocity_radius=0.5,
+ mutation_prob=0.02,
+ reset_velocity_radius=0.02,
+ reflective_bound=6.0,
+ description="test broader normalized initialization",
+ ),
+ "G7": V6GeometryConfig(
+ config_id="G7",
+ scale_type="per_tensor_sd",
+ init_position_mode="independent",
+ position_radius=0.5,
+ initial_velocity_radius=0.5,
+ mutation_prob=0.0,
+ reflective_bound=3.0,
+ description="isolate antithetic position coupling against G2",
+ ),
+ "G8": V6GeometryConfig(
+ config_id="G8",
+ scale_type="optimizer_default",
+ init_position_mode="independent",
+ position_radius=0.05,
+ initial_velocity_radius=0.05,
+ mutation_prob=0.02,
+ reset_velocity_radius=0.02,
+ reflective_bound=3.0,
+ description="retained semantic control (public Optimizer)",
+ ),
+ }
+
+
+def compute_equalized_subspace_radius(
+ latent_dim: int,
+ total_dim: int = 9098,
+ base_radius: float = 0.5,
+) -> float:
+ """
+ Computes equalized subspace initialization/bound radius for Phase C.
+ Scales base_radius by sqrt(total_dim / latent_dim) to hold decoded per-parameter RMS constant.
+ """
+ if latent_dim >= total_dim:
+ return base_radius
+ return float(base_radius * math.sqrt(total_dim / latent_dim))
+
+
+# =====================================================================
+# 3. Deterministic Latent Transform & Swarm Construction
+# =====================================================================
+
+class V6LatentTransform:
+ def __init__(
+ self,
+ base_model: nn.Module,
+ geom_config: V6GeometryConfig,
+ device: torch.device,
+ ):
+ self.device = device
+ self.geom_config = geom_config
+ self.base_params = [p.detach().clone().to(device) for p in base_model.parameters()]
+ self.param_shapes = [p.shape for p in self.base_params]
+ self.param_numels = [p.numel() for p in self.base_params]
+ self.total_dim = sum(self.param_numels)
+ self.base_vec = torch.cat([p.view(-1) for p in self.base_params]).to(device)
+
+ scale_type = geom_config.scale_type.lower()
+ if scale_type == "per_tensor_sd":
+ tensor_scales = []
+ for p in self.base_params:
+ std_val = float(p.std())
+ scale = max(std_val, 1e-4)
+ scale_tensor = torch.full_like(p, scale)
+ tensor_scales.append(scale_tensor.view(-1))
+ self.scale_vec = torch.cat(tensor_scales).to(device)
+ elif scale_type == "global_rms":
+ rms_val = float(torch.sqrt(torch.mean(self.base_vec ** 2)))
+ scale = max(rms_val, 1e-4)
+ self.scale_vec = torch.full_like(self.base_vec, scale, device=device)
+ elif scale_type == "identity":
+ self.scale_vec = torch.ones_like(self.base_vec, device=device)
+ else:
+ # Default fallback for optimizer or custom
+ self.scale_vec = torch.ones_like(self.base_vec, device=device)
+
+ latent_dim = geom_config.latent_dim
+ if isinstance(latent_dim, str) and latent_dim.lower() == "full":
+ self.latent_dim = self.total_dim
+ self.is_full = True
+ else:
+ self.latent_dim = int(latent_dim)
+ self.is_full = (self.latent_dim == self.total_dim)
+
+ if not self.is_full:
+ j_indices = np.arange(self.total_dim, dtype=np.int64)
+ seed_offset = geom_config.projection_seed if geom_config.projection_seed is not None else 0
+ h1 = ((j_indices + 1 + seed_offset) * 2654435761) % (2**32)
+ k_indices = h1 % self.latent_dim
+ h2 = ((j_indices + 1 + seed_offset) * 1597334677) % (2**32)
+ signs = np.where((h2 % 2) == 0, 1.0, -1.0)
+
+ bin_counts = np.bincount(k_indices, minlength=self.latent_dim)
+ count_per_j = bin_counts[k_indices]
+ scale_per_j = 1.0 / np.sqrt(np.maximum(count_per_j, 1))
+ combined_weights = signs * scale_per_j
+
+ self.k_indices = torch.tensor(k_indices, dtype=torch.long, device=device)
+ self.weights = torch.tensor(combined_weights, dtype=torch.float32, device=device)
+
+ def decode(self, Z: torch.Tensor) -> torch.Tensor:
+ """
+ Transforms latent batch Z (N, d) into full parameter batch (N, D).
+ theta = base_vec + scale_vec * delta
+ """
+ if self.is_full:
+ delta = Z
+ else:
+ delta = Z[:, self.k_indices] * self.weights
+ return self.base_vec + self.scale_vec * delta
+
+ def load_vector_to_model(self, theta_vec: torch.Tensor, model: nn.Module):
+ """Loads a single parameter vector into model parameters in-place."""
+ offset = 0
+ with torch.no_grad():
+ for p, shape, numel in zip(model.parameters(), self.param_shapes, self.param_numels):
+ p.copy_(theta_vec[offset:offset + numel].view(shape))
+ offset += numel
+
+ def init_swarm(self, swarm_size: int, seed: int) -> torch.Tensor:
+ """
+ Initializes particle positions in latent space Z (N, d).
+ Particle 0 is exact base vector (z = 0).
+ Uses a separate CPU generator to preserve G0 parity with V5.
+ """
+ init_radius = self.geom_config.position_radius
+ mode = self.geom_config.init_position_mode.lower()
+
+ rng = torch.Generator(device="cpu")
+ rng.manual_seed(seed)
+
+ Z = torch.zeros((swarm_size, self.latent_dim), dtype=torch.float32)
+
+ if mode == "antithetic":
+ max_pair_idx = swarm_size - 1 if (swarm_size % 2 != 0) else swarm_size - 2
+ idx = 1
+ while idx < max_pair_idx:
+ sample = (torch.rand(self.latent_dim, generator=rng) * 2.0 - 1.0) * init_radius
+ Z[idx] = sample
+ Z[idx + 1] = -sample
+ idx += 2
+ else: # independent
+ for idx in range(1, swarm_size):
+ Z[idx] = (torch.rand(self.latent_dim, generator=rng) * 2.0 - 1.0) * init_radius
+
+ return Z.to(self.device)
+
+
+# =====================================================================
+# 4. Device-Resident Configurable V6 Latent Adaptive-Moment PSO Engine
+# =====================================================================
+
+def evaluate_latent_batch(
+ Z: torch.Tensor,
+ transform: V6LatentTransform,
+ model: nn.Module,
+ x_sub_dev: torch.Tensor,
+ y_sub_dev: torch.Tensor,
+ batch_size: int = 1000,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ """
+ Evaluates latent batch Z (N, d) on device-resident (x_sub_dev, y_sub_dev).
+ Returns (losses, accuracies) tensors of shape (N,).
+ """
+ N = Z.shape[0]
+ device = Z.device
+ losses = torch.zeros(N, dtype=torch.float32, device=device)
+ accuracies = torch.zeros(N, dtype=torch.float32, device=device)
+
+ loss_fn = nn.CrossEntropyLoss(reduction="sum")
+ num_samples = len(y_sub_dev)
+
+ model.eval()
+ with torch.inference_mode():
+ for i in range(N):
+ theta_vec = transform.decode(Z[i:i+1]).squeeze(0)
+ transform.load_vector_to_model(theta_vec, model)
+
+ total_loss = torch.tensor(0.0, device=device)
+ correct = torch.tensor(0, dtype=torch.long, device=device)
+
+ for b_start in range(0, num_samples, batch_size):
+ xb = x_sub_dev[b_start:b_start + batch_size]
+ yb = y_sub_dev[b_start:b_start + batch_size]
+ logits = model(xb)
+ batch_loss = loss_fn(logits, yb)
+ total_loss += batch_loss
+ preds = logits.argmax(dim=1)
+ correct += (preds == yb).sum()
+
+ losses[i] = total_loss / num_samples
+ accuracies[i] = (correct.float() / num_samples) * 100.0
+
+ return losses, accuracies
+
+
+def run_v6_pso(
+ transform: V6LatentTransform,
+ base_model: nn.Module,
+ x_search: torch.Tensor,
+ y_search: torch.Tensor,
+ x_val: torch.Tensor,
+ y_val: torch.Tensor,
+ nested_subsets: Dict[int, torch.Tensor],
+ schedule_str: str,
+ epochs: int,
+ swarm_size: int,
+ seed: int,
+ device: torch.device,
+ geom_config: V6GeometryConfig,
+ val_check_interval: int = 10,
+ transition_reset_policy: str = "none",
+) -> Dict[str, Any]:
+ """
+ Device-resident Latent Adaptive-Moment PSO for V6 study.
+ Supports G0-G7 configurations, nonzero launch velocity, mutation moment reset,
+ reflective bounds, state-neutral validation checkpoints, and full telemetry.
+ """
+ sync_device(device)
+ start_time = time.time()
+ validation_wall_time = 0.0
+
+ schedule_stages = []
+ if schedule_str:
+ parts = schedule_str.split(",")
+ for p in parts:
+ sz_str, ep_str = p.split(":")
+ schedule_stages.append((int(sz_str), int(ep_str)))
+
+ if not schedule_stages:
+ schedule_stages = [(50000, epochs)]
+
+ c0 = c1 = 1.49618
+ w = 0.7298
+ blend = 0.06
+ step = 0.5
+ beta1 = 0.9
+ beta2 = 0.999
+ reflective_bound = geom_config.reflective_bound
+
+ latent_dim = transform.latent_dim
+ Z = transform.init_swarm(swarm_size=swarm_size, seed=seed)
+
+ # Initial launch velocity
+ if geom_config.initial_velocity_radius > 0.0:
+ vel_rng = torch.Generator(device="cpu")
+ vel_rng.manual_seed(seed + 1000)
+ r_v = geom_config.initial_velocity_radius
+ V_cpu = (torch.rand((swarm_size, latent_dim), generator=vel_rng) * 2.0 - 1.0) * r_v
+ V_cpu[0] = 0.0 # Particle 0 launch velocity remains zero
+ V = V_cpu.to(device)
+ else:
+ V = torch.zeros((swarm_size, latent_dim), dtype=torch.float32, device=device)
+
+ M = torch.zeros((swarm_size, latent_dim), dtype=torch.float32, device=device)
+ V_sq = torch.zeros((swarm_size, latent_dim), dtype=torch.float32, device=device)
+ moment_steps = torch.zeros(swarm_size, dtype=torch.int64, device=device)
+
+ P = Z.clone()
+ P_loss = torch.full((swarm_size,), float("inf"), dtype=torch.float32, device=device)
+ P_acc = torch.zeros((swarm_size,), dtype=torch.float32, device=device)
+
+ gbest_z = Z[0].clone()
+ gbest_loss = float("inf")
+ gbest_acc = 0.0
+
+ # Counters & Telemetry
+ total_queries = 0
+ total_sample_evaluations = 0
+ transition_reevaluation_counts = 0
+ validation_evaluations = 0
+ pbest_update_counts = 0
+ boundary_hits = 0
+ last_improvement_epoch = 0
+ mutation_events = 0
+
+ # Random generators: move_rng handles standard velocity draws; mut_rng handles mutation draws
+ move_rng = torch.Generator(device=device)
+ move_rng.manual_seed(seed)
+ mut_rng = torch.Generator(device=device)
+ mut_rng.manual_seed(seed + 2000)
+
+ model = copy.deepcopy(base_model).to(device)
+ x_val_dev = x_val.to(device)
+ y_val_dev = y_val.to(device)
+
+ stage_histories = []
+ epoch_counter = 0
+
+ for stage_idx, (size, stage_epochs) in enumerate(schedule_stages):
+ subset_indices = nested_subsets[size]
+ x_sub_dev = x_search[subset_indices].to(device)
+ y_sub_dev = y_search[subset_indices].to(device)
+
+ # Objective transition check
+ if stage_idx > 0:
+ re_losses, re_accs = evaluate_latent_batch(
+ P, transform, model, x_sub_dev, y_sub_dev
+ )
+ P_loss = re_losses
+ P_acc = re_accs
+
+ total_queries += swarm_size
+ total_sample_evaluations += swarm_size * size
+ transition_reevaluation_counts += swarm_size
+
+ min_loss_val = P_loss.min()
+ candidates_mask = (P_loss <= min_loss_val + 1e-7)
+ best_p_idx = int(torch.where(candidates_mask, P_acc, torch.tensor(-1.0, device=device)).argmax().item())
+
+ gbest_z = P[best_p_idx].clone()
+ gbest_loss = float(P_loss[best_p_idx].item())
+ gbest_acc = float(P_acc[best_p_idx].item())
+
+ # Transition reset policy
+ if transition_reset_policy in ("reset_vm", "reset_all"):
+ V.zero_()
+ M.zero_()
+ V_sq.zero_()
+ moment_steps.zero_()
+
+ for ep in range(1, stage_epochs + 1):
+ epoch_counter += 1
+
+ # 1. Evaluate current swarm positions
+ curr_losses, curr_accs = evaluate_latent_batch(
+ Z, transform, model, x_sub_dev, y_sub_dev
+ )
+ total_queries += swarm_size
+ total_sample_evaluations += swarm_size * size
+
+ # 2. Vectorized pbest updates
+ better_loss = curr_losses < P_loss - 1e-7
+ equal_loss = torch.abs(curr_losses - P_loss) <= 1e-7
+ better_acc = curr_accs > P_acc
+ update_mask = better_loss | (equal_loss & better_acc)
+
+ n_updated = int(update_mask.sum().item())
+ pbest_update_counts += n_updated
+ if n_updated > 0:
+ last_improvement_epoch = epoch_counter
+
+ P[update_mask] = Z[update_mask]
+ P_loss[update_mask] = curr_losses[update_mask]
+ P_acc[update_mask] = curr_accs[update_mask]
+
+ # Rebuild gbest from P each epoch
+ min_loss_val = P_loss.min()
+ candidates_mask = (P_loss <= min_loss_val + 1e-7)
+ best_p_idx = int(torch.where(candidates_mask, P_acc, torch.tensor(-1.0, device=device)).argmax().item())
+
+ gbest_z = P[best_p_idx].clone()
+ gbest_loss = float(P_loss[best_p_idx].item())
+ gbest_acc = float(P_acc[best_p_idx].item())
+
+ # Validation Checkpoint (State-Neutral)
+ val_loss = None
+ val_acc = None
+ if val_check_interval > 0 and (epoch_counter % val_check_interval == 0 or epoch_counter == epochs):
+ sync_device(device)
+ validation_start = time.time()
+ with torch.inference_mode():
+ v_losses, v_accs = evaluate_latent_batch(
+ gbest_z.unsqueeze(0), transform, model, x_val_dev, y_val_dev
+ )
+ val_loss = float(v_losses[0].item())
+ val_acc = float(v_accs[0].item())
+ validation_evaluations += 1
+ sync_device(device)
+ validation_wall_time += time.time() - validation_start
+
+ stage_histories.append({
+ "epoch": epoch_counter,
+ "stage": stage_idx,
+ "subset_size": size,
+ "gbest_loss": round(gbest_loss, 6),
+ "gbest_acc": round(gbest_acc, 4),
+ "val_loss": round(val_loss, 6) if val_loss is not None else None,
+ "val_acc": round(val_acc, 4) if val_acc is not None else None,
+ })
+
+ # 3. Movement Step
+ r1 = torch.rand((swarm_size, latent_dim), generator=move_rng, device=device)
+ r2 = torch.rand((swarm_size, latent_dim), generator=move_rng, device=device)
+
+ V_raw = w * V + c0 * r1 * (P - Z) + c1 * r2 * (gbest_z.unsqueeze(0) - Z)
+
+ # Mutation check
+ if geom_config.mutation_prob > 0.0:
+ mut_draws = torch.rand(swarm_size, generator=mut_rng, device=device)
+ mut_mask = mut_draws < geom_config.mutation_prob
+ if mut_mask.any():
+ n_mut = int(mut_mask.sum().item())
+ r_mut = geom_config.reset_velocity_radius
+ mut_v = (torch.rand((n_mut, latent_dim), generator=mut_rng, device=device) * 2.0 - 1.0) * r_mut
+ V_raw[mut_mask] = mut_v
+ # Clear moment state for mutated particles
+ M[mut_mask] = 0.0
+ V_sq[mut_mask] = 0.0
+ moment_steps[mut_mask] = 0
+ mutation_events += n_mut
+
+ moment_steps += 1
+ M = beta1 * M + (1 - beta1) * V_raw
+ V_sq = beta2 * V_sq + (1 - beta2) * (V_raw ** 2)
+
+ step_values = moment_steps.to(dtype=M.dtype).unsqueeze(1)
+ M_hat = M / (1.0 - torch.pow(beta1, step_values))
+ V_sq_hat = V_sq / (1.0 - torch.pow(beta2, step_values))
+
+ dir_moment = M_hat / (torch.sqrt(V_sq_hat) + 1e-8)
+ historical_scale = torch.sqrt(torch.mean(V_sq_hat, dim=1, keepdim=True))
+ V_moment = step * dir_moment * historical_scale
+ V_new = (1.0 - blend) * V_raw + blend * V_moment
+
+ Z_new = Z + V_new
+
+ pos_mask = Z_new > reflective_bound
+ neg_mask = Z_new < -reflective_bound
+ hit_mask = pos_mask | neg_mask
+ boundary_hits += int(hit_mask.sum().item())
+
+ Z_new[pos_mask] = 2.0 * reflective_bound - Z_new[pos_mask]
+ V_new[pos_mask] = -V_new[pos_mask]
+
+ Z_new[neg_mask] = -2.0 * reflective_bound - Z_new[neg_mask]
+ V_new[neg_mask] = -V_new[neg_mask]
+
+ Z_new = torch.clamp(Z_new, -reflective_bound, reflective_bound)
+
+ Z = Z_new
+ V = V_new
+
+ if epoch_counter >= epochs:
+ break
+ if epoch_counter >= epochs:
+ break
+
+ sync_device(device)
+ validation_start = time.time()
+ # Select the best final pbest on validation, matching the G8 control.
+ pbest_val_losses, pbest_val_accs = evaluate_latent_batch(
+ P, transform, model, x_val_dev, y_val_dev
+ )
+ validation_evaluations += swarm_size
+ min_val_loss = pbest_val_losses.min()
+ val_candidates = pbest_val_losses <= min_val_loss + 1e-7
+ val_best_idx = int(
+ torch.where(
+ val_candidates,
+ pbest_val_accs,
+ torch.tensor(-1.0, device=device),
+ ).argmax().item()
+ )
+
+ val_selected_model = copy.deepcopy(base_model).to(device)
+ theta_selected = transform.decode(P[val_best_idx].unsqueeze(0)).squeeze(0)
+ transform.load_vector_to_model(theta_selected, val_selected_model)
+ val_probabilities = get_model_probabilities(val_selected_model, x_val_dev, device)
+ val_metrics = evaluate_probabilistic_metrics(val_probabilities, y_val_dev)
+ validation_evaluations += 1
+ sync_device(device)
+ validation_wall_time += time.time() - validation_start
+
+ gbest_val_loss = float(pbest_val_losses[best_p_idx].item())
+ gbest_val_acc = float(pbest_val_accs[best_p_idx].item())
+
+ wall_time = time.time() - start_time
+ optimization_wall_time = max(0.0, wall_time - validation_wall_time)
+
+ velocity_rms = float(torch.sqrt(torch.mean(V ** 2)).item())
+ position_radius = float(torch.norm(Z - Z.mean(dim=0), dim=1).mean().item())
+ total_coords = swarm_size * latent_dim * max(epoch_counter, 1)
+ boundary_occupancy = round(boundary_hits / max(total_coords, 1), 6)
+
+ return {
+ "config_id": geom_config.config_id,
+ "gbest_z": gbest_z,
+ "gbest_loss": round(gbest_loss, 6),
+ "gbest_acc": round(gbest_acc, 4),
+ "gbest_val_loss": round(gbest_val_loss, 6),
+ "gbest_val_acc": round(gbest_val_acc, 4),
+ "val_selected_particle_idx": val_best_idx,
+ "val_selected_loss": round(val_metrics["nll"], 6),
+ "val_selected_acc": round(val_metrics["accuracy"], 4),
+ "val_metrics": val_metrics,
+ "final_P": P,
+ "wall_time_sec": round(wall_time, 4),
+ "optimization_wall_time_sec": round(optimization_wall_time, 4),
+ "validation_wall_time_sec": round(validation_wall_time, 4),
+ "total_queries": total_queries,
+ "total_sample_evaluations": total_sample_evaluations,
+ "transition_reevaluation_counts": transition_reevaluation_counts,
+ "validation_evaluations": validation_evaluations,
+ "official_test_evaluations": 0,
+ "mutation_events": mutation_events,
+ "final_moment_steps": moment_steps.detach().cpu().tolist(),
+ "pbest_update_counts": pbest_update_counts,
+ "boundary_hits": boundary_hits,
+ "boundary_occupancy": boundary_occupancy,
+ "last_improvement_epoch": last_improvement_epoch,
+ "velocity_rms": round(velocity_rms, 6),
+ "position_radius": round(position_radius, 6),
+ "stage_histories": stage_histories,
+ }
+
+
+# =====================================================================
+# 5. Public Optimizer G8 Semantic Control Engine
+# =====================================================================
+
+def run_g8_optimizer(
+ base_model: nn.Module,
+ x_2k: torch.Tensor,
+ y_2k: torch.Tensor,
+ x_val: torch.Tensor,
+ y_val: torch.Tensor,
+ epochs: int,
+ swarm_size: int,
+ seed: int,
+ device: torch.device,
+) -> Dict[str, Any]:
+ """
+ Runs public Optimizer for G8 semantic control over the exact 2k search tensors.
+ Evaluates every particle's pbest on validation to select the endpoint.
+ Retains training gbest metrics separately.
+ Official test evaluations count is explicitly zero.
+ """
+ from pso.optimizer import Optimizer
+ sync_device(device)
+ start_t = time.time()
+
+ model = copy.deepcopy(base_model).to(device)
+ loss_fn = nn.CrossEntropyLoss()
+ validation_loss_fn = nn.CrossEntropyLoss(reduction="sum")
+
+ opt = Optimizer(
+ model=model,
+ loss=loss_fn,
+ task="multiclass",
+ method="adaptive_moment",
+ evaluation="full",
+ n_particles=swarm_size,
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ particle_min=-3.0,
+ particle_max=3.0,
+ boundary_strategy="reflect",
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ initialization="model_noise",
+ initial_position_noise=0.05,
+ moment_blend=0.06,
+ moment_step_size=0.5,
+ moment_beta1=0.9,
+ seed=seed,
+ device=device,
+ )
+
+ x_2k_dev = x_2k.to(device)
+ y_2k_dev = y_2k.to(device)
+
+ best_score = opt.fit(x_2k_dev, y_2k_dev, epochs=epochs, renewal="loss")
+ sync_device(device)
+ optimization_wall_time = time.time() - start_t
+ validation_start = time.time()
+
+ # Evaluate every particle pbest vector on the validation set
+ val_losses = []
+ val_accs = []
+ pbest_models = []
+
+ x_val_dev = x_val.to(device)
+ y_val_dev = y_val.to(device)
+ num_val = len(y_val_dev)
+
+ for p in opt.particles:
+ p_model = copy.deepcopy(base_model).to(device)
+ offset = 0
+ with torch.no_grad():
+ for param in p_model.parameters():
+ n = param.numel()
+ param.copy_(p.personal_best_weights[offset:offset + n].view(param.shape))
+ offset += n
+
+ p_model.eval()
+ with torch.inference_mode():
+ total_loss = 0.0
+ correct = 0
+ for b_start in range(0, num_val, 1000):
+ xb = x_val_dev[b_start:b_start + 1000]
+ yb = y_val_dev[b_start:b_start + 1000]
+ logits = p_model(xb)
+ total_loss += float(validation_loss_fn(logits, yb).item())
+ correct += int((logits.argmax(dim=1) == yb).sum().item())
+ val_loss = total_loss / num_val
+ val_acc = (correct / num_val) * 100.0
+
+ val_losses.append(val_loss)
+ val_accs.append(val_acc)
+ pbest_models.append(p_model)
+
+ # Rank particles on validation NLL ascending, val accuracy descending
+ min_val_loss = min(val_losses)
+ val_candidates = [
+ index
+ for index, loss in enumerate(val_losses)
+ if loss <= min_val_loss + 1e-7
+ ]
+ best_idx = max(val_candidates, key=lambda index: val_accs[index])
+
+ val_selected_model = pbest_models[best_idx]
+ val_probabilities = get_model_probabilities(val_selected_model, x_val_dev, device)
+ val_metrics = evaluate_probabilistic_metrics(val_probabilities, y_val_dev)
+ sync_device(device)
+ validation_wall_time = time.time() - validation_start
+ wall_t = optimization_wall_time + validation_wall_time
+
+ total_queries = swarm_size * epochs
+ total_sample_evaluations = total_queries * len(y_2k)
+ validation_evaluations = swarm_size + 1
+
+ return {
+ "config_id": "G8",
+ "gbest_loss": round(float(best_score[0]), 6),
+ "gbest_acc": round(float(best_score[1]) * 100.0, 4),
+ "val_selected_loss": round(val_metrics["nll"], 6),
+ "val_selected_acc": round(val_metrics["accuracy"], 4),
+ "val_metrics": val_metrics,
+ "wall_time_sec": round(wall_t, 4),
+ "optimization_wall_time_sec": round(optimization_wall_time, 4),
+ "validation_wall_time_sec": round(validation_wall_time, 4),
+ "total_queries": total_queries,
+ "total_sample_evaluations": total_sample_evaluations,
+ "transition_reevaluation_counts": 0,
+ "validation_evaluations": validation_evaluations,
+ "official_test_evaluations": 0,
+ "pbest_update_counts": 0,
+ "boundary_hits": 0,
+ "boundary_occupancy": 0.0,
+ "last_improvement_epoch": epochs,
+ "velocity_rms": 0.0,
+ "position_radius": 0.0,
+ "stage_histories": [],
+ }
+
+
+# =====================================================================
+# 6. Selection & Paired Factor Analysis
+# =====================================================================
+
+def compute_paired_factor_deltas(
+ screen_results: Dict[str, Dict[str, Any]]
+) -> Dict[str, Dict[str, float]]:
+ """
+ Computes paired factor deltas for Phase B screen.
+ A factor is provisionally material if NLL improves by >= 0.05 or Acc improves by >= 2.0pp.
+ """
+ pairs = [
+ ("delta_scale_G1_vs_G0", "G1", "G0", "global RMS scale vs per-tensor SD"),
+ ("delta_vel_G2_vs_G0", "G2", "G0", "launch velocity U(-0.5,0.5) vs 0"),
+ ("delta_mut_G3_vs_G0", "G3", "G0", "mutation 0.02 vs 0"),
+ ("delta_vel_mut_G4_vs_G2", "G4", "G2", "mutation interaction given velocity"),
+ ("delta_bound_G5_vs_G4", "G5", "G4", "bound box 6 vs 3"),
+ ("delta_radius_G6_vs_G5", "G6", "G5", "initial position radius 1.5 vs 0.5"),
+ ("delta_init_G7_vs_G2", "G7", "G2", "independent vs antithetic init"),
+ ]
+
+ deltas = {}
+ for key, c_test, c_ref, desc in pairs:
+ if c_test in screen_results and c_ref in screen_results:
+ r_test = screen_results[c_test]
+ r_ref = screen_results[c_ref]
+ nll_diff = round(r_test["val_selected_loss"] - r_ref["val_selected_loss"], 6)
+ acc_diff = round(r_test["val_selected_acc"] - r_ref["val_selected_acc"], 4)
+ is_material = (nll_diff <= -0.05) or (acc_diff >= 2.0)
+ deltas[key] = {
+ "test_config": c_test,
+ "ref_config": c_ref,
+ "nll_diff": nll_diff,
+ "acc_diff": acc_diff,
+ "material": is_material,
+ "description": desc,
+ }
+
+ # Bundle comparison: G8 vs best normalized config
+ norm_configs = [c for c in screen_results if c != "G8"]
+ if norm_configs:
+ best_norm_id = min(norm_configs, key=lambda k: (screen_results[k]["val_selected_loss"], -screen_results[k]["val_selected_acc"]))
+ r_g8 = screen_results["G8"]
+ r_best_norm = screen_results[best_norm_id]
+ nll_diff = round(r_g8["val_selected_loss"] - r_best_norm["val_selected_loss"], 6)
+ acc_diff = round(r_g8["val_selected_acc"] - r_best_norm["val_selected_acc"], 4)
+ deltas["delta_bundle_G8_vs_best_norm"] = {
+ "test_config": "G8",
+ "ref_config": best_norm_id,
+ "nll_diff": nll_diff,
+ "acc_diff": acc_diff,
+ "material": abs(nll_diff) >= 0.05 or abs(acc_diff) >= 2.0,
+ "description": f"Optimizer G8 control vs best normalized ({best_norm_id})",
+ }
+
+ return deltas
+
+
+def select_confirmation_configs(
+ screen_results: Dict[str, Dict[str, Any]]
+) -> List[str]:
+ """
+ Deterministically selects G0, G1, G8 plus top 2 eligible normalized configs from G2-G7.
+ """
+ mandatory = ["G0", "G1", "G8"]
+ eligible = ["G2", "G3", "G4", "G5", "G6", "G7"]
+
+ # Filter available eligible configs
+ valid_eligible = [c for c in eligible if c in screen_results]
+ valid_eligible.sort(
+ key=lambda c: (screen_results[c]["val_selected_loss"], -screen_results[c]["val_selected_acc"])
+ )
+
+ top2_other = valid_eligible[:2]
+ selected = mandatory + top2_other
+ return selected
+
+
+def evaluate_root_cause_statuses(
+ confirm_aggregates: Dict[str, Dict[str, Any]]
+) -> Dict[str, Dict[str, Any]]:
+ """Classify each predeclared geometry hypothesis from confirmed mean metrics."""
+ statuses: Dict[str, Dict[str, Any]] = {}
+ g8_stats = confirm_aggregates.get("G8")
+
+ if g8_stats is None:
+ statuses["regression_recovered"] = {
+ "status": "unresolved",
+ "recovered_configs": [],
+ "description": "G8 control was not confirmed",
+ }
+ else:
+ g8_acc = g8_stats["val_selected_acc"]["mean"]
+ g8_nll = g8_stats["val_selected_nll"]["mean"]
+ recovered = []
+ for cid, stats in confirm_aggregates.items():
+ if cid == "G8":
+ continue
+ acc = stats["val_selected_acc"]["mean"]
+ nll = stats["val_selected_nll"]["mean"]
+ if acc >= g8_acc - 1.0 and nll <= g8_nll + 0.05:
+ recovered.append(cid)
+ statuses["regression_recovered"] = {
+ "status": "supported" if recovered else "rejected",
+ "recovered_configs": recovered,
+ "g8_mean_acc": g8_acc,
+ "g8_mean_nll": g8_nll,
+ "description": "Normalized geometry is within 1.0pp accuracy and 0.05 NLL of G8",
+ }
+
+ hypotheses = [
+ ("anisotropic_per_tensor_scaling", "G1", "G0", "global RMS scale versus per-tensor SD"),
+ ("nonzero_launch_velocity", "G2", "G0", "nonzero launch velocity versus zero"),
+ ("mutation", "G3", "G0", "mutation 0.02 versus none"),
+ ("velocity_mutation_interaction", "G4", "G2", "mutation given nonzero velocity"),
+ ("bound_expansion", "G5", "G4", "normalized bound 6 versus 3"),
+ ("broader_initialization", "G6", "G5", "initial radius 1.5 versus 0.5"),
+ ("independent_initialization", "G7", "G2", "independent versus antithetic positions"),
+ ]
+ for name, test_id, ref_id, description in hypotheses:
+ if test_id not in confirm_aggregates or ref_id not in confirm_aggregates:
+ statuses[name] = {
+ "status": "unresolved",
+ "test_config": test_id,
+ "ref_config": ref_id,
+ "description": description,
+ }
+ continue
+ test_stats = confirm_aggregates[test_id]
+ ref_stats = confirm_aggregates[ref_id]
+ nll_diff = (
+ test_stats["val_selected_nll"]["mean"]
+ - ref_stats["val_selected_nll"]["mean"]
+ )
+ acc_diff = (
+ test_stats["val_selected_acc"]["mean"]
+ - ref_stats["val_selected_acc"]["mean"]
+ )
+ supported = nll_diff <= -0.05 or acc_diff >= 2.0
+ statuses[name] = {
+ "status": "supported" if supported else "rejected",
+ "test_config": test_id,
+ "ref_config": ref_id,
+ "mean_nll_diff": round(nll_diff, 6),
+ "mean_acc_diff": round(acc_diff, 4),
+ "description": description,
+ }
+
+ return statuses
+
+
+def artifact_safe_run(result: Dict[str, Any]) -> Dict[str, Any]:
+ """Drop engine-only state and convert remaining tensor values for JSON."""
+ safe: Dict[str, Any] = {}
+ for key, value in result.items():
+ if key in {"gbest_z", "final_P"}:
+ continue
+ if torch.is_tensor(value):
+ value = value.detach().cpu().item() if value.numel() == 1 else value.detach().cpu().tolist()
+ safe[key] = value
+ return safe
+
+
+# =====================================================================
+# 7. Experiment Runner Pipeline (Screen, Confirm, All)
+# =====================================================================
+
+def run_phase_b_screen(
+ x_search: torch.Tensor,
+ y_search: torch.Tensor,
+ x_val: torch.Tensor,
+ y_val: torch.Tensor,
+ nested_subsets: Dict[int, torch.Tensor],
+ device: torch.device,
+ seed: int = 91,
+ swarm_size: int = 30,
+ epochs: int = 160,
+) -> Dict[str, Any]:
+ """Runs Phase B screen (G0 - G8 at seed 91)."""
+ table = get_v6_geometry_table()
+ screen_results = {}
+
+ for cid in ["G0", "G1", "G2", "G3", "G4", "G5", "G6", "G7"]:
+ cfg = table[cid]
+ base_model = make_compact_cnn(seed=41).to(device)
+ transform = V6LatentTransform(base_model, cfg, device)
+ res = run_v6_pso(
+ transform=transform,
+ base_model=base_model,
+ x_search=x_search,
+ y_search=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ nested_subsets=nested_subsets,
+ schedule_str=f"2000:{epochs}",
+ epochs=epochs,
+ swarm_size=swarm_size,
+ seed=seed,
+ device=device,
+ geom_config=cfg,
+ )
+ res["seed"] = seed
+ res["geometry_config"] = asdict(cfg)
+ screen_results[cid] = artifact_safe_run(res)
+
+ # Run G8
+ base_model_g8 = make_compact_cnn(seed=41).to(device)
+ x_2k = x_search[nested_subsets[2000]]
+ y_2k = y_search[nested_subsets[2000]]
+ g8_res = run_g8_optimizer(
+ base_model=base_model_g8,
+ x_2k=x_2k,
+ y_2k=y_2k,
+ x_val=x_val,
+ y_val=y_val,
+ epochs=epochs,
+ swarm_size=swarm_size,
+ seed=seed,
+ device=device,
+ )
+ g8_res["seed"] = seed
+ g8_res["geometry_config"] = asdict(table["G8"])
+ screen_results["G8"] = artifact_safe_run(g8_res)
+
+ # Paired factor deltas & confirmation selection
+ factor_deltas = compute_paired_factor_deltas(screen_results)
+ selected_for_confirm = select_confirmation_configs(screen_results)
+
+ return {
+ "phase": "screen",
+ "seed": seed,
+ "swarm_size": swarm_size,
+ "epochs": epochs,
+ "screen_results": screen_results,
+ "factor_deltas": factor_deltas,
+ "selected_for_confirm": selected_for_confirm,
+ }
+
+
+def run_phase_b_confirm(
+ selected_configs: List[str],
+ x_search: torch.Tensor,
+ y_search: torch.Tensor,
+ x_val: torch.Tensor,
+ y_val: torch.Tensor,
+ nested_subsets: Dict[int, torch.Tensor],
+ device: torch.device,
+ seeds: List[int] = [101, 102, 103],
+ swarm_size: int = 60,
+ epochs: int = 420,
+) -> Dict[str, Any]:
+ """Runs Phase B confirmation over selected configurations across seeds 101-103."""
+ table = get_v6_geometry_table()
+ confirm_runs = {cid: [] for cid in selected_configs}
+
+ x_2k = x_search[nested_subsets[2000]]
+ y_2k = y_search[nested_subsets[2000]]
+
+ for cid in selected_configs:
+ for seed in seeds:
+ if cid == "G8":
+ base_model = make_compact_cnn(seed=41).to(device)
+ res = run_g8_optimizer(
+ base_model=base_model,
+ x_2k=x_2k,
+ y_2k=y_2k,
+ x_val=x_val,
+ y_val=y_val,
+ epochs=epochs,
+ swarm_size=swarm_size,
+ seed=seed,
+ device=device,
+ )
+ else:
+ cfg = table[cid]
+ base_model = make_compact_cnn(seed=41).to(device)
+ transform = V6LatentTransform(base_model, cfg, device)
+ res = run_v6_pso(
+ transform=transform,
+ base_model=base_model,
+ x_search=x_search,
+ y_search=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ nested_subsets=nested_subsets,
+ schedule_str=f"2000:{epochs}",
+ epochs=epochs,
+ swarm_size=swarm_size,
+ seed=seed,
+ device=device,
+ geom_config=cfg,
+ )
+ res["seed"] = seed
+ res["geometry_config"] = asdict(table[cid])
+ confirm_runs[cid].append(artifact_safe_run(res))
+
+ # Compute aggregate stats per config across seeds
+ confirm_aggregates = {}
+ for cid, runs in confirm_runs.items():
+ accs = [r["val_selected_acc"] for r in runs]
+ nlls = [r["val_selected_loss"] for r in runs]
+ briers = [r["val_metrics"]["brier"] for r in runs if "val_metrics" in r and "brier" in r["val_metrics"]]
+ eces = [r["val_metrics"]["ece"] for r in runs if "val_metrics" in r and "ece" in r["val_metrics"]]
+
+ confirm_aggregates[cid] = {
+ "val_selected_acc": calc_stats(accs),
+ "val_selected_nll": calc_stats(nlls),
+ "brier": calc_stats(briers) if briers else {},
+ "ece": calc_stats(eces) if eces else {},
+ "num_seeds": len(runs),
+ }
+
+ root_cause_statuses = evaluate_root_cause_statuses(confirm_aggregates)
+
+ return {
+ "phase": "confirm",
+ "seeds": seeds,
+ "swarm_size": swarm_size,
+ "epochs": epochs,
+ "selected_configs": selected_configs,
+ "confirm_runs": confirm_runs,
+ "confirm_aggregates": confirm_aggregates,
+ "root_cause_statuses": root_cause_statuses,
+ }
+
+
+# =====================================================================
+# 8. CSV & Plot Artifact Writers
+# =====================================================================
+
+def save_csv_summary_v6(payload: Dict[str, Any], csv_path: Path):
+ """Saves concise CSV summary of V6 study results."""
+ import csv
+ csv_path.parent.mkdir(parents=True, exist_ok=True)
+
+ with open(csv_path, "w", newline="") as f:
+ writer = csv.writer(f)
+ writer.writerow(["protocol_version", payload.get("protocol_version", PROTOCOL_VERSION)])
+ writer.writerow([])
+
+ if "screen_payload" in payload and "screen_results" in payload["screen_payload"]:
+ writer.writerow(["--- Phase B Screen Results ---"])
+ writer.writerow(["config_id", "description", "val_nll", "val_acc_%", "queries", "sample_evals", "wall_time_sec"])
+ table = get_v6_geometry_table()
+ s_results = payload["screen_payload"]["screen_results"]
+ for cid in sorted(s_results.keys()):
+ r = s_results[cid]
+ desc = table[cid].description if cid in table else ""
+ writer.writerow([
+ cid, desc,
+ r["val_selected_loss"],
+ r["val_selected_acc"],
+ r["total_queries"],
+ r["total_sample_evaluations"],
+ r["wall_time_sec"],
+ ])
+ writer.writerow([])
+
+ if "confirm_payload" in payload and "confirm_aggregates" in payload["confirm_payload"]:
+ writer.writerow(["--- Phase B Confirmation Aggregates ---"])
+ writer.writerow(["config_id", "mean_val_acc_%", "std_val_acc", "mean_val_nll", "std_val_nll", "num_seeds"])
+ c_aggs = payload["confirm_payload"]["confirm_aggregates"]
+ for cid in sorted(c_aggs.keys()):
+ agg = c_aggs[cid]
+ writer.writerow([
+ cid,
+ agg["val_selected_acc"]["mean"],
+ agg["val_selected_acc"]["std"],
+ agg["val_selected_nll"]["mean"],
+ agg["val_selected_nll"]["std"],
+ agg["num_seeds"],
+ ])
+
+
+def generate_study_plots_v6(payload: Dict[str, Any], plot_path: Path):
+ """Generates validation trajectory & comparison figures for V6 study."""
+ plot_path.parent.mkdir(parents=True, exist_ok=True)
+ fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+
+ # Left subplot: Validation Trajectories from Screen
+ ax_traj = axes[0]
+ if "screen_payload" in payload and "screen_results" in payload["screen_payload"]:
+ s_results = payload["screen_payload"]["screen_results"]
+ for cid, res in s_results.items():
+ if "stage_histories" in res and res["stage_histories"]:
+ epochs = [h["epoch"] for h in res["stage_histories"] if h.get("val_loss") is not None]
+ nlls = [h["val_loss"] for h in res["stage_histories"] if h.get("val_loss") is not None]
+ if epochs and nlls:
+ ax_traj.plot(epochs, nlls, label=cid, alpha=0.8)
+ elif cid == "G8":
+ ax_traj.scatter(
+ [payload["screen_payload"]["epochs"]],
+ [res["val_selected_loss"]],
+ marker="x",
+ s=60,
+ label="G8 final",
+ )
+
+ ax_traj.set_title("Screen Validation NLL Trajectory")
+ ax_traj.set_xlabel("Epoch")
+ ax_traj.set_ylabel("Validation NLL")
+ ax_traj.grid(True, linestyle="--", alpha=0.5)
+ ax_traj.legend(fontsize=8, loc="upper right")
+
+ # Right subplot: Confirmation Mean Validation Accuracy Bar Chart
+ ax_bar = axes[1]
+ if "confirm_payload" in payload and "confirm_aggregates" in payload["confirm_payload"]:
+ c_aggs = payload["confirm_payload"]["confirm_aggregates"]
+ cids = sorted(c_aggs.keys())
+ means = [c_aggs[c]["val_selected_acc"]["mean"] for c in cids]
+ stds = [c_aggs[c]["val_selected_acc"]["std"] for c in cids]
+
+ colors = ["skyblue" if c != "G8" else "coral" for c in cids]
+ ax_bar.bar(cids, means, yerr=stds, capsize=5, color=colors, alpha=0.85)
+ ax_bar.set_ylabel("Mean Validation Accuracy (%)")
+ ax_bar.set_title("Confirmation Accuracy (3 Seeds)")
+ ax_bar.set_ylim(0, 100)
+ for i, (m, s) in enumerate(zip(means, stds)):
+ ax_bar.text(i, m + s + 1.0, f"{m:.1f}%", ha="center", va="bottom", fontsize=8)
+
+ plt.tight_layout()
+ fig.savefig(plot_path, dpi=200)
+ plt.close(fig)
+
+
+# =====================================================================
+# 9. Main CLI Entrypoint
+# =====================================================================
+
+def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(description="MNIST Deep PSO V6 Root-Cause Study (Phase A & B)")
+ parser.add_argument("--phase", type=str, choices=["screen", "confirm", "all"], default="all", help="Phase to execute")
+ parser.add_argument("--device", type=str, default=None, help="Execution device (e.g. mps, cuda, cpu)")
+ parser.add_argument("--screen-artifact", type=str, default="benchmark_results/pso_v6_phase_b_screen.json", help="Path to screen artifact for confirm phase")
+ parser.add_argument("--out-dir", type=str, default="benchmark_results", help="Output directory for results")
+ parser.add_argument("--plot-dir", type=str, default="history_plt", help="Output directory for plots")
+ parser.add_argument("--override-particles", type=int, default=None, help="Override particle count for testing/smokes")
+ parser.add_argument("--override-epochs", type=int, default=None, help="Override epoch count for testing/smokes")
+ return parser
+
+
+def run_deep_pso_v6_study(args: argparse.Namespace) -> Dict[str, Any]:
+ device = resolve_execution_device(args.device)
+ out_dir = Path(args.out_dir)
+ plot_dir = Path(args.plot_dir)
+
+ out_dir.mkdir(parents=True, exist_ok=True)
+ plot_dir.mkdir(parents=True, exist_ok=True)
+
+ # 1. Prepare data strictly without test set
+ x_search, y_search, x_val, y_val, nested_subsets, data_fp, provenance = prepare_mnist_v6_data()
+ hw_prov = get_hardware_provenance(device)
+ geometry_table = get_v6_geometry_table()
+ base_model = make_compact_cnn(seed=41)
+
+ final_payload: Dict[str, Any] = {
+ "protocol_version": PROTOCOL_VERSION,
+ "pso_version": pso_version,
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "data_fingerprint": data_fp,
+ "base_model_seed": 41,
+ "base_model_fingerprint": compute_model_fingerprint(base_model),
+ "geometry_configs": {
+ config_id: asdict(config)
+ for config_id, config in geometry_table.items()
+ },
+ "selection_rule": "lowest_validation_nll_then_highest_accuracy",
+ "provenance": provenance,
+ "hardware_provenance": hw_prov,
+ "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+ }
+
+ screen_payload = None
+ confirm_payload = None
+
+ screen_particles = args.override_particles if args.override_particles is not None else 30
+ screen_epochs = args.override_epochs if args.override_epochs is not None else 160
+
+ confirm_particles = args.override_particles if args.override_particles is not None else 60
+ confirm_epochs = args.override_epochs if args.override_epochs is not None else 420
+
+ # 2. Execute Screen Phase if requested or in 'all'
+ if args.phase in ("screen", "all"):
+ screen_payload = run_phase_b_screen(
+ x_search=x_search,
+ y_search=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ nested_subsets=nested_subsets,
+ device=device,
+ seed=91,
+ swarm_size=screen_particles,
+ epochs=screen_epochs,
+ )
+ final_payload["screen_payload"] = screen_payload
+ save_json_atomic(final_payload, out_dir / "pso_v6_phase_b_screen.json")
+
+ # 3. Execute Confirm Phase if requested or in 'all'
+ if args.phase in ("confirm", "all"):
+ if screen_payload is not None:
+ selected_configs = screen_payload["selected_for_confirm"]
+ else:
+ screen_art_path = Path(args.screen_artifact)
+ if screen_art_path.exists():
+ import json
+ with open(screen_art_path, "r") as f:
+ art_data = json.load(f)
+ selected_configs = art_data.get("screen_payload", {}).get("selected_for_confirm", ["G0", "G1", "G8"])
+ else:
+ selected_configs = ["G0", "G1", "G8", "G2", "G4"]
+
+ confirm_payload = run_phase_b_confirm(
+ selected_configs=selected_configs,
+ x_search=x_search,
+ y_search=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ nested_subsets=nested_subsets,
+ device=device,
+ seeds=[101, 102, 103],
+ swarm_size=confirm_particles,
+ epochs=confirm_epochs,
+ )
+ final_payload["confirm_payload"] = confirm_payload
+
+ persisted_runs: List[Dict[str, Any]] = []
+ if screen_payload is not None:
+ persisted_runs.extend(screen_payload["screen_results"].values())
+ if confirm_payload is not None:
+ for runs in confirm_payload["confirm_runs"].values():
+ persisted_runs.extend(runs)
+ final_payload["resource_totals"] = {
+ "candidate_objective_queries": sum(r["total_queries"] for r in persisted_runs),
+ "candidate_sample_evaluations": sum(
+ r["total_sample_evaluations"] for r in persisted_runs
+ ),
+ "validation_model_evaluations": sum(
+ r["validation_evaluations"] for r in persisted_runs
+ ),
+ "summed_optimization_wall_time_sec": round(
+ sum(r["optimization_wall_time_sec"] for r in persisted_runs), 4
+ ),
+ "summed_validation_wall_time_sec": round(
+ sum(r["validation_wall_time_sec"] for r in persisted_runs), 4
+ ),
+ "official_test_evaluations": 0,
+ }
+
+ # Save final atomic JSON, CSV, and plots
+ json_path = out_dir / "pso_v6_phase_b.json"
+ csv_path = out_dir / "pso_v6_phase_b.csv"
+ plot_path = plot_dir / "pso_v6_phase_b.png"
+
+ save_json_atomic(final_payload, json_path)
+ save_csv_summary_v6(final_payload, csv_path)
+ generate_study_plots_v6(final_payload, plot_path)
+
+ return final_payload
+
+
+if __name__ == "__main__":
+ parser = build_parser()
+ args = parser.parse_args()
+ run_deep_pso_v6_study(args)
diff --git a/test/digits.py b/test/digits.py
index e9fb16a..f5b4bf6 100644
--- a/test/digits.py
+++ b/test/digits.py
@@ -1,71 +1,111 @@
-import os
-import sys
-
-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.datasets import load_digits
from sklearn.model_selection import train_test_split
+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 make_model():
- model = Sequential()
- model.add(Dense(12, input_dim=64, activation="relu"))
- model.add(Dense(10, activation="relu"))
- model.add(Dense(10, activation="softmax"))
-
- return model
+def make_model(seed: int = 42):
+ torch.manual_seed(seed)
+ return nn.Sequential(
+ nn.Linear(64, 12),
+ nn.ReLU(),
+ nn.Linear(12, 10),
+ nn.ReLU(),
+ nn.Linear(10, 10),
+ )
-def get_data():
+def get_data(seed: int = 42):
digits = load_digits()
- X = digits.data
- y = digits.target
-
- x = X.astype("float32")
-
- y_class = to_categorical(y)
+ x = digits.data.astype("float32")
+ y = digits.target.astype("int64")
x_train, x_test, y_train, y_test = train_test_split(
- x, y_class, test_size=0.2, random_state=42, shuffle=True
+ x, y, test_size=0.2, random_state=seed, shuffle=True
+ )
+ 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(x_test, dtype=torch.float32),
+ torch.tensor(y_train, dtype=torch.int64),
+ torch.tensor(y_test, dtype=torch.int64),
)
- return x_train, x_test, y_train, y_test
-x_train, x_test, y_train, y_test = get_data()
-model = make_model()
+def main():
+ parser = argparse.ArgumentParser(description="PSO Digits Benchmark Script")
+ add_pso_args(
+ parser,
+ defaults={
+ "method": "original",
+ "initialization": "model_noise",
+ "evaluation": "fixed_subset",
+ "convergence": "particle_reset",
+ "refinement": "adam",
+ "n_particles": 30,
+ "c0": None,
+ "c1": None,
+ "w_min": None,
+ "w_max": None,
+ "negative_swarm": 0.0,
+ "mutation_swarm": 0.1,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "velocity_limit_ratio": 0.1,
+ "boundary_strategy": "reflect",
+ "seed": 42,
+ "epochs": 80,
+ "batch_size": 200,
+ "fitness_size": 1000,
+ "renewal": "loss",
+ "output_dir": "output/digits",
+ "refinement_epochs": 10,
+ "refinement_lr": 0.001,
+ },
+ )
+ args = parser.parse_args()
-digits_pso = optimizer(
- model,
- loss="categorical_crossentropy",
- n_particles=300,
- c0=0.5,
- c1=0.3,
- w_min=0.2,
- w_max=0.9,
- negative_swarm=0,
- mutation_swarm=0.1,
- convergence_reset=True,
- convergence_reset_patience=10,
- convergence_reset_monitor="loss",
- convergence_reset_min_delta=0.001,
-)
+ x_train, x_test, y_train, y_test = get_data(seed=args.seed)
+ model = make_model(seed=args.seed)
-digits_pso.fit(
- x_train,
- y_train,
- epochs=500,
- validate_data=(x_test, y_test),
- log=2,
- save_info=True,
- renewal="loss",
- log_name="digits",
-)
+ fitness_size = args.fitness_size if args.evaluation == "fixed_subset" else None
+ refinement_epochs = args.refinement_epochs if args.refinement == "adam" else 0
-print("Done!")
+ kwargs = build_optimizer_kwargs(
+ args,
+ model=model,
+ loss=nn.CrossEntropyLoss(),
+ task="multiclass",
+ inertia_profile={"c0": 0.5, "c1": 0.3, "w_min": 0.2, "w_max": 0.9},
+ )
+ digits_pso = Optimizer(**kwargs)
-sys.exit(0)
+ print(f"Optimizer device: {digits_pso.device}")
+
+ best_score = digits_pso.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,
+ save_info=True,
+ refinement_epochs=refinement_epochs,
+ refinement_lr=args.refinement_lr,
+ )
+
+ print(f"Done! Best score: {best_score}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/digits_tf.py b/test/digits_tf.py
deleted file mode 100644
index fb06966..0000000
--- a/test/digits_tf.py
+++ /dev/null
@@ -1,81 +0,0 @@
-import os
-import sys
-
-import pandas as pd
-import tensorflow as tf
-from sklearn.datasets import load_digits
-from sklearn.model_selection import train_test_split
-from tensorflow import keras
-from tensorflow.keras import layers
-from tensorflow.keras.layers import Dense
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.utils import to_categorical
-
-
-gpus = tf.config.experimental.list_physical_devices("GPU")
-if gpus:
- try:
- tf.config.experimental.set_memory_growth(gpus[0], True)
- except RuntimeError as r:
- print(r)
-
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
-
-
-def make_model():
- model = Sequential()
- model.add(Dense(12, input_dim=64, activation="relu"))
- model.add(Dense(12, activation="relu"))
- model.add(Dense(10, activation="softmax"))
-
- return model
-
-
-def get_data():
- digits = load_digits()
- X = digits.data
- y = digits.target
-
- x = X.astype("float32")
-
- y_class = to_categorical(y)
-
- x_train, x_test, y_train, y_test = train_test_split(
- x, y_class, test_size=0.2, random_state=42, shuffle=True
- )
- return x_train, x_test, y_train, y_test
-
-
-if __name__ == "__main__":
- model = make_model()
- x_train, x_test, y_train, y_test = get_data()
-
- callbacks = [
- tf.keras.callbacks.EarlyStopping(
- monitor="val_loss", patience=10, restore_best_weights=True
- )
- ]
-
- print(x_train.shape, y_train.shape)
-
- model.compile(
- optimizer="adam",
- loss="categorical_crossentropy",
- metrics=["accuracy", "mse"],
- )
-
- print(model.summary())
-
- history = model.fit(
- x_train,
- y_train,
- epochs=500,
- batch_size=32,
- verbose=1,
- validation_data=(x_test, y_test),
- callbacks=callbacks,
- )
-
- print("Done!")
-
- sys.exit(0)
diff --git a/test/digits_torch.py b/test/digits_torch.py
new file mode 100644
index 0000000..1c702fa
--- /dev/null
+++ b/test/digits_torch.py
@@ -0,0 +1,134 @@
+"""Digits dataset gradient baseline (PyTorch standard backprop optimizer, non-PSO)."""
+
+import copy
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.datasets import load_digits
+from sklearn.model_selection import train_test_split
+
+
+class DigitsModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.net = nn.Sequential(
+ nn.Linear(64, 12),
+ nn.ReLU(),
+ nn.Linear(12, 12),
+ nn.ReLU(),
+ nn.Linear(12, 10),
+ )
+
+ def forward(self, x):
+ return self.net(x)
+
+
+def get_data(seed: int = 42):
+ digits = load_digits()
+ X = digits.data.astype("float32")
+ y = digits.target.astype("int64")
+
+ x_train, x_test, y_train, y_test = train_test_split(
+ X, y, test_size=0.2, random_state=seed, shuffle=True
+ )
+ return (
+ torch.tensor(x_train, dtype=torch.float32),
+ torch.tensor(x_test, dtype=torch.float32),
+ torch.tensor(y_train, dtype=torch.int64),
+ torch.tensor(y_test, dtype=torch.int64),
+ )
+
+
+def get_device() -> torch.device:
+ if (
+ hasattr(torch.backends, "mps")
+ and torch.backends.mps.is_built()
+ and torch.backends.mps.is_available()
+ ):
+ return torch.device("mps")
+ elif torch.cuda.is_available():
+ return torch.device("cuda")
+ return torch.device("cpu")
+
+
+def main():
+ torch.manual_seed(42)
+ np.random.seed(42)
+
+ device = get_device()
+ print(f"Selected device: {device}")
+
+ x_train, x_test, y_train, y_test = get_data(seed=42)
+ train_loader = DataLoader(
+ TensorDataset(x_train, y_train), batch_size=32, shuffle=True
+ )
+ val_loader = DataLoader(
+ TensorDataset(x_test, y_test), batch_size=32, shuffle=False
+ )
+
+ model = DigitsModel().to(device)
+ optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+ criterion = nn.CrossEntropyLoss()
+
+ best_val_loss = float("inf")
+ best_state = None
+ patience = 10
+ patience_counter = 0
+
+ for epoch in range(500):
+ model.train()
+ for bx, by in train_loader:
+ bx, by = bx.to(device), by.to(device)
+ optimizer.zero_grad()
+ out = model(bx)
+ loss = criterion(out, by)
+ loss.backward()
+ optimizer.step()
+
+ model.eval()
+ val_loss = 0.0
+ total = 0
+ with torch.no_grad():
+ for bx, by in val_loader:
+ bx, by = bx.to(device), by.to(device)
+ out = model(bx)
+ loss = criterion(out, by)
+ val_loss += loss.item() * bx.size(0)
+ total += bx.size(0)
+
+ val_loss /= total
+
+ if val_loss < best_val_loss:
+ best_val_loss = val_loss
+ best_state = copy.deepcopy(model.state_dict())
+ patience_counter = 0
+ else:
+ patience_counter += 1
+ if patience_counter >= patience:
+ break
+
+ if best_state is not None:
+ model.load_state_dict(best_state)
+
+ model.eval()
+ test_loss = 0.0
+ correct = 0
+ total = 0
+ with torch.no_grad():
+ for bx, by in val_loader:
+ bx, by = bx.to(device), by.to(device)
+ out = model(bx)
+ loss = criterion(out, by)
+ test_loss += loss.item() * bx.size(0)
+ preds = out.argmax(dim=1)
+ correct += (preds == by).sum().item()
+ total += bx.size(0)
+
+ test_loss /= total
+ test_acc = correct / total
+ print(f"Final test loss: {test_loss:.4f}, accuracy: {test_acc:.4f}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/epoch_convergence.py b/test/epoch_convergence.py
new file mode 100644
index 0000000..e14c1b6
--- /dev/null
+++ b/test/epoch_convergence.py
@@ -0,0 +1,673 @@
+"""
+Adaptive Moment 120-Particle x 240-Epoch MNIST Convergence & Trajectory Analysis
+
+Evaluates whether the published 120-particle x 80-epoch MNIST PCA32 Adaptive Moment run
+benefits from continued optimization up to 240 epochs or enters a generalization plateau.
+
+Predeclared Contract Criteria:
+1. Exact Replay Verification at Epoch 80 (seeds 71-75):
+ Per-seed test accuracy absolute delta vs baseline <= 0.005 (0.5%p).
+2. Primary Diagnostic Endpoints: Epochs 80, 120, 160, 200, 240.
+3. Classifications:
+ - Training Still Improving: Mean global-best fitness loss falls >= 1% from epoch 80 to 240.
+ - Meaningful Held-Out Gain: Mean test accuracy at epoch 240 rises >= 1 percentage point vs epoch 80.
+ - Overfitting Signal: Training loss improves but epoch 240 test accuracy falls >= 1 point.
+ - Early Stagnation: Training loss improves < 1% and absolute test change remains < 1 point.
+ - Generalization Plateau: Training loss improves >= 1% while absolute test gain remains < 1 point.
+ - Late Plateau Diagnostic: 200->240 training-loss improvement < 1% AND absolute test-accuracy change < 0.5 points.
+"""
+
+import argparse
+import csv
+import datetime
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+
+# Ensure test/ directory is in sys.path
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from benchmark_suite import (
+ calc_stats,
+ compute_model_fingerprint,
+ get_hardware_provenance,
+ make_mnist_model,
+ resolve_execution_device,
+ save_json_atomic,
+ sync_device,
+)
+from pso import Optimizer, __version__ as pso_version
+from reproduce_scaling import (
+ REPLAY_SEEDS,
+ REPLAY_TOLERANCE,
+ prepare_full_pca_data,
+ validate_and_load_baseline,
+)
+from tuning_suite import TUNING_PROTOCOL_VERSION
+
+EPOCH_CONVERGENCE_PROTOCOL_VERSION = "1.0.0"
+CHECKPOINT_EPOCHS = [20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 220, 240]
+POST80_LOSS_REDUCTION_THRESHOLD = 0.01
+TEST_ACCURACY_GAIN_THRESHOLD = 0.01
+OVERFITTING_ACCURACY_DROP_THRESHOLD = -0.01
+LATE_LOSS_REDUCTION_THRESHOLD = 0.01
+LATE_ACCURACY_CHANGE_THRESHOLD = 0.005
+
+
+def run_epoch_convergence_analysis(
+ baseline_path: Path,
+ output_json_path: Path,
+ output_csv_path: Path,
+ figure_path: Path,
+ device_str: str | None = None,
+) -> bool:
+ device = resolve_execution_device(device_str)
+ hw_provenance = get_hardware_provenance(device)
+
+ # 1. Validate and load baseline
+ baseline_data, baseline_records, winner_cfg, expected_fp = validate_and_load_baseline(
+ baseline_path
+ )
+ if baseline_data.get("device") != device.type:
+ raise ValueError(
+ f"Exact trajectory extension requires baseline device "
+ f"{baseline_data.get('device')!r}; got {device.type!r}."
+ )
+ if baseline_data.get("pso_version") != pso_version:
+ raise ValueError(
+ f"Exact trajectory extension requires pso version "
+ f"{baseline_data.get('pso_version')!r}; got {pso_version!r}."
+ )
+ if baseline_data.get("torch_version") != torch.__version__:
+ raise ValueError(
+ f"Exact trajectory extension requires torch version "
+ f"{baseline_data.get('torch_version')!r}; got {torch.__version__!r}."
+ )
+
+ base_rec_by_seed = {r["seed"]: r for r in baseline_records}
+
+ # 2. Prepare full PCA dataset
+ x_full_tr, y_train_3000, x_full_test, y_test_1000, data_fp = prepare_full_pca_data()
+ if data_fp != expected_fp:
+ raise ValueError(
+ f"Data fingerprint mismatch: computed {data_fp}, baseline expected {expected_fp}"
+ )
+
+ opt_kwargs = winner_cfg.to_optimizer_kwargs(quick=False)
+ n_particles = 120
+ target_epochs = 240
+ batch_size = 1000
+
+ runs: List[Dict[str, Any]] = []
+ flat_csv_rows: List[Dict[str, Any]] = []
+ fidelity_passed = True
+ seed_fidelity_deltas: Dict[int, float] = {}
+
+ # 3. Process seeds 71-75
+ for seed in sorted(REPLAY_SEEDS):
+ base_rec = base_rec_by_seed[seed]
+ expected_model_fp = base_rec["model_fingerprint"]
+ baseline_test_acc = float(base_rec["test_acc"])
+
+ # --- Untimed 2-Epoch Warmup Phase ---
+ warmup_model = make_mnist_model(seed=seed)
+ warmup_loss = nn.CrossEntropyLoss()
+ warmup_opt = Optimizer(
+ model=warmup_model,
+ loss=warmup_loss,
+ task="multiclass",
+ n_particles=n_particles,
+ seed=seed,
+ device=device,
+ **opt_kwargs,
+ )
+ warmup_opt.fit(
+ x_full_tr,
+ y_train_3000,
+ epochs=2,
+ batch_size=batch_size,
+ renewal="loss",
+ )
+ sync_device(device)
+ del warmup_opt, warmup_model, warmup_loss
+
+ # --- Timed 240-Epoch Continuous Trajectory ---
+ model = make_mnist_model(seed=seed)
+ model_fp = compute_model_fingerprint(model)
+ fp_match = (model_fp == expected_model_fp)
+ if not fp_match:
+ print(
+ f"[WARNING] Seed {seed} model fingerprint mismatch: "
+ f"got {model_fp}, expected {expected_model_fp}"
+ )
+ fidelity_passed = False
+
+ loss_inst = nn.CrossEntropyLoss()
+ opt = Optimizer(
+ model=model,
+ loss=loss_inst,
+ task="multiclass",
+ n_particles=n_particles,
+ seed=seed,
+ device=device,
+ **opt_kwargs,
+ )
+
+ with tempfile.TemporaryDirectory() as temp_dir_str:
+ output_dir = Path(temp_dir_str)
+
+ sync_device(device)
+ t0 = time.perf_counter()
+ train_loss_final, train_acc_final, train_mse_final = opt.fit(
+ x_full_tr,
+ y_train_3000,
+ epochs=target_epochs,
+ batch_size=batch_size,
+ renewal="loss",
+ output_dir=output_dir,
+ log_format="csv",
+ checkpoint_interval=20,
+ )
+ sync_device(device)
+ t1 = time.perf_counter()
+ fit_time_sec = t1 - t0
+
+ # Read full epoch history from history.csv
+ history_csv_path = output_dir / "history.csv"
+ epoch_history = []
+ with open(history_csv_path, "r", encoding="utf-8") as f:
+ reader = csv.DictReader(f)
+ for row in reader:
+ epoch_history.append({
+ "epoch": int(row["epoch"]),
+ "loss": float(row["loss"]),
+ "accuracy": float(row["accuracy"]),
+ "mse": float(row["mse"]),
+ })
+
+ # Track training global-best improvement epochs
+ prev_best_loss = float("inf")
+ improvement_count = 0
+ last_improvement_epoch = 1
+ for row in epoch_history:
+ ep_num = row["epoch"]
+ l_val = row["loss"]
+ if l_val < prev_best_loss:
+ improvement_count += 1
+ last_improvement_epoch = ep_num
+ prev_best_loss = l_val
+
+ # Read and evaluate checkpoints
+ checkpoints: List[Dict[str, Any]] = []
+ ckpt_dir = output_dir / "checkpoints"
+ epoch80_test_acc = None
+
+ for ep in CHECKPOINT_EPOCHS:
+ ckpt_path = ckpt_dir / f"epoch-{ep}.pt"
+ if not ckpt_path.exists():
+ raise FileNotFoundError(f"Missing checkpoint file: {ckpt_path}")
+
+ payload = torch.load(ckpt_path, map_location=device, weights_only=True)
+ ckpt_train_loss, ckpt_train_acc, ckpt_train_mse = payload["score"]
+
+ # Load checkpoint state_dict into opt.eval_model and evaluate on held-out test tensor
+ opt.eval_model.load_state_dict(payload["model_state_dict"])
+ opt._global_best_weights = opt.codec.encode(opt.eval_model)
+ test_loss, test_acc, test_mse = opt.evaluate(x_full_test, y_test_1000)
+
+ ckpt_record = {
+ "epoch": ep,
+ "train_loss": float(ckpt_train_loss),
+ "train_acc": float(ckpt_train_acc),
+ "train_mse": float(ckpt_train_mse),
+ "test_loss": float(test_loss),
+ "test_acc": float(test_acc),
+ "test_mse": float(test_mse),
+ }
+ checkpoints.append(ckpt_record)
+
+ if ep == 80:
+ epoch80_test_acc = float(test_acc)
+
+ flat_csv_rows.append({
+ "seed": seed,
+ "epoch": ep,
+ "train_loss": float(ckpt_train_loss),
+ "train_acc": float(ckpt_train_acc),
+ "train_mse": float(ckpt_train_mse),
+ "test_loss": float(test_loss),
+ "test_acc": float(test_acc),
+ "test_mse": float(test_mse),
+ "fit_time_sec": round(fit_time_sec, 4),
+ })
+
+ # Fidelity check at epoch 80 vs baseline
+ assert epoch80_test_acc is not None
+ delta_ep80 = abs(epoch80_test_acc - baseline_test_acc)
+ seed_fidelity_deltas[seed] = delta_ep80
+
+ if delta_ep80 > REPLAY_TOLERANCE:
+ print(
+ f"[WARNING] Seed {seed} epoch 80 test accuracy delta {delta_ep80:.6f} "
+ f"exceeds tolerance {REPLAY_TOLERANCE} (actual={epoch80_test_acc:.4f}, baseline={baseline_test_acc:.4f})"
+ )
+ fidelity_passed = False
+
+ runs.append({
+ "seed": seed,
+ "model_fingerprint": model_fp,
+ "expected_model_fingerprint": expected_model_fp,
+ "fingerprint_matched": fp_match,
+ "baseline_epoch80_test_acc": baseline_test_acc,
+ "epoch80_test_acc": epoch80_test_acc,
+ "epoch80_abs_delta": delta_ep80,
+ "fit_time_sec": round(fit_time_sec, 4),
+ "improvement_count": improvement_count,
+ "last_improvement_epoch": last_improvement_epoch,
+ "checkpoints": checkpoints,
+ })
+
+ max_ep80_delta = max(seed_fidelity_deltas.values()) if seed_fidelity_deltas else 0.0
+
+ # 4. Aggregations and Statistical Summaries
+ checkpoint_stats: Dict[int, Dict[str, Any]] = {}
+ for ep in CHECKPOINT_EPOCHS:
+ ep_train_losses = [next(c["train_loss"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+ ep_train_accs = [next(c["train_acc"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+ ep_train_mses = [next(c["train_mse"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+
+ ep_test_losses = [next(c["test_loss"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+ ep_test_accs = [next(c["test_acc"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+ ep_test_mses = [next(c["test_mse"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+
+ checkpoint_stats[ep] = {
+ "train_loss": calc_stats(ep_train_losses),
+ "train_acc": calc_stats(ep_train_accs),
+ "train_mse": calc_stats(ep_train_mses),
+ "test_loss": calc_stats(ep_test_losses),
+ "test_acc": calc_stats(ep_test_accs),
+ "test_mse": calc_stats(ep_test_mses),
+ }
+
+ # Endpoint paired deltas (80->240 and 200->240)
+ deltas_80_to_240_train_rel = []
+ deltas_80_to_240_test_acc = []
+
+ deltas_200_to_240_train_rel = []
+ deltas_200_to_240_test_acc = []
+ deltas_200_to_240_test_acc_abs = []
+
+ for r in runs:
+ ckpt_map = {c["epoch"]: c for c in r["checkpoints"]}
+
+ # 80 to 240
+ tl80 = ckpt_map[80]["train_loss"]
+ tl240 = ckpt_map[240]["train_loss"]
+ rel_red_80_240 = (tl80 - tl240) / tl80 if tl80 > 0 else 0.0
+ deltas_80_to_240_train_rel.append(rel_red_80_240)
+
+ ta80 = ckpt_map[80]["test_acc"]
+ ta240 = ckpt_map[240]["test_acc"]
+ acc_delta_80_240 = ta240 - ta80
+ deltas_80_to_240_test_acc.append(acc_delta_80_240)
+
+ # 200 to 240
+ tl200 = ckpt_map[200]["train_loss"]
+ rel_red_200_240 = (tl200 - tl240) / tl200 if tl200 > 0 else 0.0
+ deltas_200_to_240_train_rel.append(rel_red_200_240)
+
+ ta200 = ckpt_map[200]["test_acc"]
+ acc_delta_200_240 = ta240 - ta200
+ acc_abs_change_200_240 = abs(ta240 - ta200)
+ deltas_200_to_240_test_acc.append(acc_delta_200_240)
+ deltas_200_to_240_test_acc_abs.append(acc_abs_change_200_240)
+
+ # Calculate overall mean metrics for classifications
+ mean_train_loss_80 = checkpoint_stats[80]["train_loss"]["mean"]
+ mean_train_loss_200 = checkpoint_stats[200]["train_loss"]["mean"]
+ mean_train_loss_240 = checkpoint_stats[240]["train_loss"]["mean"]
+
+ mean_test_acc_80 = checkpoint_stats[80]["test_acc"]["mean"]
+ mean_test_acc_200 = checkpoint_stats[200]["test_acc"]["mean"]
+ mean_test_acc_240 = checkpoint_stats[240]["test_acc"]["mean"]
+
+ rel_train_loss_reduction_80_240 = (
+ (mean_train_loss_80 - mean_train_loss_240) / mean_train_loss_80
+ )
+ test_acc_gain_80_240 = mean_test_acc_240 - mean_test_acc_80
+
+ rel_train_loss_reduction_200_240 = (
+ (mean_train_loss_200 - mean_train_loss_240) / mean_train_loss_200
+ )
+ abs_test_acc_change_200_240 = abs(mean_test_acc_240 - mean_test_acc_200)
+
+ # 5. Shared Contract Predeclared Classifications
+ post_80_training_converging = bool(
+ rel_train_loss_reduction_80_240 >= POST80_LOSS_REDUCTION_THRESHOLD
+ )
+ meaningful_held_out_gain = bool(
+ test_acc_gain_80_240 >= TEST_ACCURACY_GAIN_THRESHOLD
+ )
+ overfitting_signal = bool(
+ post_80_training_converging
+ and test_acc_gain_80_240 <= OVERFITTING_ACCURACY_DROP_THRESHOLD
+ )
+ early_stagnation = bool(
+ not post_80_training_converging
+ and abs(test_acc_gain_80_240) < TEST_ACCURACY_GAIN_THRESHOLD
+ )
+ generalization_plateau = bool(
+ post_80_training_converging
+ and not meaningful_held_out_gain
+ and not overfitting_signal
+ )
+ late_plateau_diagnostic = bool(
+ rel_train_loss_reduction_200_240 < LATE_LOSS_REDUCTION_THRESHOLD
+ and abs_test_acc_change_200_240 < LATE_ACCURACY_CHANGE_THRESHOLD
+ )
+
+ if meaningful_held_out_gain:
+ summary_verdict = (
+ f"Training beyond epoch 80 continues to improve held-out test accuracy by "
+ f"{test_acc_gain_80_240 * 100:.2f} percentage points "
+ f"(from {mean_test_acc_80 * 100:.2f}% to {mean_test_acc_240 * 100:.2f}%)."
+ )
+ elif overfitting_signal:
+ summary_verdict = (
+ f"Training beyond epoch 80 exhibits overfitting: training loss falls by "
+ f"{rel_train_loss_reduction_80_240 * 100:.2f}% while held-out test accuracy drops by "
+ f"{abs(test_acc_gain_80_240) * 100:.2f} percentage points."
+ )
+ elif early_stagnation:
+ summary_verdict = (
+ f"Optimization has effectively stagnated after epoch 80: training loss falls by only "
+ f"{rel_train_loss_reduction_80_240 * 100:.2f}% and held-out accuracy changes by "
+ f"{test_acc_gain_80_240 * 100:+.2f} percentage points through epoch 240."
+ )
+ elif generalization_plateau:
+ summary_verdict = (
+ f"Training loss continues to improve after epoch 80, but held-out accuracy plateaus: "
+ f"{test_acc_gain_80_240 * 100:+.2f} percentage points "
+ f"(from {mean_test_acc_80 * 100:.2f}% to {mean_test_acc_240 * 100:.2f}%)."
+ )
+ else:
+ summary_verdict = (
+ "The fixed endpoint criteria are inconclusive; inspect the paired checkpoint "
+ "trajectory before extending the epoch horizon."
+ )
+
+ last_improvement_epochs_dict = {r["seed"]: r["last_improvement_epoch"] for r in runs}
+ paired_endpoint_deltas = []
+ for r in runs:
+ ckpt_map = {c["epoch"]: c for c in r["checkpoints"]}
+ paired_endpoint_deltas.append(
+ {
+ "seed": r["seed"],
+ "train_loss_relative_reduction_80_to_240": (
+ ckpt_map[80]["train_loss"] - ckpt_map[240]["train_loss"]
+ )
+ / ckpt_map[80]["train_loss"],
+ "test_accuracy_delta_80_to_240": (
+ ckpt_map[240]["test_acc"] - ckpt_map[80]["test_acc"]
+ ),
+ "train_loss_relative_reduction_200_to_240": (
+ ckpt_map[200]["train_loss"] - ckpt_map[240]["train_loss"]
+ )
+ / ckpt_map[200]["train_loss"],
+ "test_accuracy_delta_200_to_240": (
+ ckpt_map[240]["test_acc"] - ckpt_map[200]["test_acc"]
+ ),
+ }
+ )
+
+
+ # Build final payload
+ payload = {
+ "epoch_convergence_protocol_version": EPOCH_CONVERGENCE_PROTOCOL_VERSION,
+ "tuning_protocol_version": TUNING_PROTOCOL_VERSION,
+ "pso_version": pso_version,
+ "torch_version": torch.__version__,
+ "hardware": hw_provenance,
+ "device": device.type,
+ "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+ "baseline_path": str(baseline_path),
+ "data_fingerprint": data_fp,
+ "candidate_label": winner_cfg.candidate_label,
+ "config": {
+ **opt_kwargs,
+ "n_particles": n_particles,
+ "epochs": target_epochs,
+ "batch_size": batch_size,
+ "renewal": "loss",
+ "checkpoint_interval": 20,
+ },
+ "contract_criteria": {
+ "primary_endpoints": [80, 120, 160, 200, 240],
+ "post_80_convergence_threshold_loss_reduction": POST80_LOSS_REDUCTION_THRESHOLD,
+ "meaningful_gain_threshold_test_acc": TEST_ACCURACY_GAIN_THRESHOLD,
+ "overfitting_threshold_test_acc": OVERFITTING_ACCURACY_DROP_THRESHOLD,
+ "late_plateau_200_240_loss_threshold": LATE_LOSS_REDUCTION_THRESHOLD,
+ "late_plateau_200_240_acc_threshold": LATE_ACCURACY_CHANGE_THRESHOLD,
+ "replay_tolerance": REPLAY_TOLERANCE,
+ },
+ "fidelity_validation": {
+ "replay_seeds": sorted(REPLAY_SEEDS),
+ "max_epoch80_test_acc_delta": round(max_ep80_delta, 6),
+ "tolerance": REPLAY_TOLERANCE,
+ "passed": fidelity_passed,
+ },
+ "predeclared_classifications": {
+ "post_80_training_converging": post_80_training_converging,
+ "meaningful_held_out_gain": meaningful_held_out_gain,
+ "overfitting_signal": overfitting_signal,
+ "early_stagnation": early_stagnation,
+ "generalization_plateau": generalization_plateau,
+ "late_plateau_diagnostic": late_plateau_diagnostic,
+ "summary_verdict": summary_verdict,
+ },
+ "summary": {
+ "epochs": CHECKPOINT_EPOCHS,
+ "checkpoint_stats": {str(ep): stats for ep, stats in checkpoint_stats.items()},
+ "paired_deltas": {
+ "80_to_240": {
+ "train_loss_rel_reduction": calc_stats(deltas_80_to_240_train_rel),
+ "test_acc_delta": calc_stats(deltas_80_to_240_test_acc),
+ },
+ "200_to_240": {
+ "train_loss_rel_reduction": calc_stats(deltas_200_to_240_train_rel),
+ "test_acc_delta": calc_stats(deltas_200_to_240_test_acc),
+ "test_acc_abs_change": calc_stats(deltas_200_to_240_test_acc_abs),
+ },
+ },
+ "paired_endpoint_deltas_by_seed": paired_endpoint_deltas,
+ "last_training_best_improvement_epochs": last_improvement_epochs_dict,
+ },
+ "runs": runs,
+ "completed": True,
+ "valid": fidelity_passed,
+ "error": None,
+ }
+
+ # Write output JSON
+ save_json_atomic(payload, output_json_path)
+ print(f"Saved analysis JSON to {output_json_path}")
+
+ # Write output CSV
+ output_csv_path.parent.mkdir(parents=True, exist_ok=True)
+ with open(output_csv_path, "w", newline="", encoding="utf-8") as f:
+ fieldnames = [
+ "seed",
+ "epoch",
+ "train_loss",
+ "train_acc",
+ "train_mse",
+ "test_loss",
+ "test_acc",
+ "test_mse",
+ "fit_time_sec",
+ ]
+ writer = csv.DictWriter(f, fieldnames=fieldnames)
+ writer.writeheader()
+ writer.writerows(flat_csv_rows)
+ print(f"Saved flat checkpoint CSV to {output_csv_path}")
+
+ # 6. Render Figure
+ render_convergence_figure(CHECKPOINT_EPOCHS, runs, checkpoint_stats, figure_path)
+ print(f"Rendered plot to {figure_path}")
+
+ # Print summary block
+ print("\n" + "=" * 70)
+ print("EPOCH CONVERGENCE & TRAJECTORY ANALYSIS RESULTS")
+ print("=" * 70)
+ print(f"Device: {device.type} | Seeds: {sorted(REPLAY_SEEDS)}")
+ print(f"Fidelity Replay Check (Epoch 80 <= {REPLAY_TOLERANCE}): Max Delta = {max_ep80_delta:.6f} -> Passed: {fidelity_passed}")
+ print("-" * 70)
+ print("Predeclared Classifications (Epoch 80 -> 240):")
+ print(f" Post-80 Training Converging (Loss Drop >= 1%): {post_80_training_converging} ({rel_train_loss_reduction_80_240 * 100:.2f}%)")
+ print(f" Meaningful Held-Out Gain (Acc Rise >= 1%p): {meaningful_held_out_gain} ({test_acc_gain_80_240 * 100:+.2f}%p)")
+ print(f" Overfitting Signal: {overfitting_signal}")
+ print(f" Early Stagnation: {early_stagnation}")
+ print(f" Generalization Plateau: {generalization_plateau}")
+ print(f" Late Plateau Diagnostic (200 -> 240): {late_plateau_diagnostic}")
+ print("-" * 70)
+ print(f"Verdict: {summary_verdict}")
+ print("=" * 70 + "\n")
+
+ return fidelity_passed
+
+
+def render_convergence_figure(
+ epochs: List[int],
+ runs: List[Dict[str, Any]],
+ checkpoint_stats: Dict[int, Dict[str, Any]],
+ figure_path: Path,
+):
+ figure_path.parent.mkdir(parents=True, exist_ok=True)
+ fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5.5))
+
+ mean_train_loss = [checkpoint_stats[ep]["train_loss"]["mean"] for ep in epochs]
+ std_train_loss = [checkpoint_stats[ep]["train_loss"]["std"] for ep in epochs]
+
+ mean_test_acc = [checkpoint_stats[ep]["test_acc"]["mean"] for ep in epochs]
+ std_test_acc = [checkpoint_stats[ep]["test_acc"]["std"] for ep in epochs]
+
+ epochs_arr = np.array(epochs)
+ mean_tl_arr = np.array(mean_train_loss)
+ std_tl_arr = np.array(std_train_loss)
+
+ mean_ta_arr = np.array(mean_test_acc)
+ std_ta_arr = np.array(std_test_acc)
+
+ # Subplot 1: Training Loss
+ for r in runs:
+ r_epochs = [c["epoch"] for c in r["checkpoints"]]
+ r_losses = [c["train_loss"] for c in r["checkpoints"]]
+ ax1.plot(r_epochs, r_losses, color="#1f77b4", alpha=0.25, linestyle=":", linewidth=1.2)
+
+ ax1.plot(epochs_arr, mean_tl_arr, marker="o", color="#1f77b4", linewidth=2.2, label="Mean Training Loss")
+ ax1.fill_between(
+ epochs_arr,
+ mean_tl_arr - std_tl_arr,
+ mean_tl_arr + std_tl_arr,
+ color="#1f77b4",
+ alpha=0.15,
+ label="±1 Std Dev",
+ )
+ ax1.axvline(80, color="#d62728", linestyle="--", linewidth=1.5, label="Baseline Horizon (Epoch 80)")
+ ax1.set_xlabel("Epoch", fontsize=11)
+ ax1.set_ylabel("Global-Best Training Loss", fontsize=11)
+ ax1.set_title("Global-Best Training Loss Trajectory", fontsize=12, fontweight="bold")
+ ax1.grid(True, alpha=0.3)
+ ax1.legend(loc="upper right", frameon=True)
+
+ # Subplot 2: Held-Out Test Accuracy
+ for r in runs:
+ r_epochs = [c["epoch"] for c in r["checkpoints"]]
+ r_accs = [c["test_acc"] for c in r["checkpoints"]]
+ ax2.plot(r_epochs, r_accs, color="#2ca02c", alpha=0.25, linestyle=":", linewidth=1.2)
+
+ ax2.plot(epochs_arr, mean_ta_arr, marker="s", color="#2ca02c", linewidth=2.2, label="Mean Test Accuracy")
+ ax2.fill_between(
+ epochs_arr,
+ mean_ta_arr - std_ta_arr,
+ mean_ta_arr + std_ta_arr,
+ color="#2ca02c",
+ alpha=0.15,
+ label="±1 Std Dev",
+ )
+ ax2.axvline(80, color="#d62728", linestyle="--", linewidth=1.5, label="Baseline Horizon (Epoch 80)")
+ ax2.set_xlabel("Epoch", fontsize=11)
+ ax2.set_ylabel("Held-Out Test Accuracy", fontsize=11)
+ ax2.set_title("Held-Out Test Accuracy Trajectory", fontsize=12, fontweight="bold")
+ ax2.grid(True, alpha=0.3)
+ ax2.legend(loc="lower right", frameon=True)
+
+ fig.suptitle(
+ "Adaptive Moment 120-Particle MNIST 240-Epoch Convergence & Trajectory Analysis",
+ fontsize=13,
+ fontweight="bold",
+ )
+ plt.tight_layout(rect=(0.0, 0.0, 1.0, 0.95))
+ plt.savefig(figure_path, dpi=300, bbox_inches="tight")
+ plt.close(fig)
+
+
+def main():
+ parser = argparse.ArgumentParser(
+ description="Adaptive Moment 120-Particle x 240-Epoch MNIST Convergence Analysis"
+ )
+ parser.add_argument(
+ "--baseline-json",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_tuning.json"),
+ help="Path to baseline tuning JSON file",
+ )
+ parser.add_argument(
+ "--output-json",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_epoch_convergence.json"),
+ help="Path to output analysis JSON file",
+ )
+ parser.add_argument(
+ "--output-csv",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_epoch_convergence.csv"),
+ help="Path to output checkpoint CSV file",
+ )
+ parser.add_argument(
+ "--figure",
+ type=Path,
+ default=Path("history_plt/pso_v4_epoch_convergence.png"),
+ help="Path to output convergence PNG figure",
+ )
+ parser.add_argument(
+ "--device",
+ type=str,
+ default=None,
+ help="Execution device (mps, cuda, cpu; default: auto-detect)",
+ )
+
+ args = parser.parse_args()
+ passed = run_epoch_convergence_analysis(
+ baseline_path=args.baseline_json,
+ output_json_path=args.output_json,
+ output_csv_path=args.output_csv,
+ figure_path=args.figure,
+ device_str=args.device,
+ )
+
+ if not passed:
+ sys.exit(1)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/evaluate_heavy_autoresearch.py b/test/evaluate_heavy_autoresearch.py
new file mode 100644
index 0000000..d8c114e
--- /dev/null
+++ b/test/evaluate_heavy_autoresearch.py
@@ -0,0 +1,539 @@
+"""
+Strict Pareto Evaluator for Heavy Task PSO Autoresearch.
+
+Evaluates candidate equalized signed-hash subspace experiment artifacts against
+baseline heavy task benchmark results (benchmark_results/pso_v6_heavy_tasks.json).
+
+Baseline Policy:
+ - mnist_compact: G8
+ - mnist_wide: G5
+ - fashion_compact: G8
+ - fashion_wide: G5
+
+Evaluates 7 Hard Gates:
+ 1. Finite Metrics (all validation metrics finite across runs)
+ 2. Test-Sealed (zero official test data loaded & 0 test evaluations)
+ 3. Config Matched (12 particles, 80 epochs, 10k subset, seeds 101-103)
+ 4. State Ratio Boundary (max state ratio <= 0.5 across all workloads)
+ 5. Workload Accuracy Regression Boundary (each workload acc regression <= 1.0 pp)
+ 6. Workload NLL Regression Boundary (each workload NLL regression <= 5.0%)
+ 7. Worst-Workload (mnist_wide) Improvement (acc gain >= 2.0 pp OR NLL reduction >= 5.0%)
+
+Numeric Score:
+ Score = mean_rel_nll_reduction_pct + mean_acc_gain_pp + 10 * log2(1 / max_state_ratio) - 100 * failed_gate_count
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+# Ensure test directory and repo root are in Python path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+from benchmark_suite import save_json_atomic
+from heavy_pso_autoresearch import compute_latent_dim, compute_core_swarm_state_bytes
+EVALUATOR_VERSION = "EVALUATE-HEAVY-AUTORESEARCH 1.0.0"
+
+BASELINE_POLICY: Dict[str, str] = {
+ "mnist_compact": "G8",
+ "mnist_wide": "G5",
+ "fashion_compact": "G8",
+ "fashion_wide": "G5",
+}
+
+EXPECTED_SEEDS = [101, 102, 103]
+EXPECTED_PARTICLES = 12
+EXPECTED_EPOCHS = 80
+EXPECTED_SUBSET_SIZE = 10000
+EXPECTED_WORKLOADS = ["mnist_compact", "mnist_wide", "fashion_compact", "fashion_wide"]
+
+
+def evaluate_heavy_autoresearch(
+ baseline_path: Union[str, Path],
+ candidate_path: Union[str, Path],
+ output_path: Optional[Union[str, Path]] = None,
+) -> Dict[str, Any]:
+ """
+ Evaluates a candidate experiment artifact against baseline heavy task results.
+ Validates schemas, configurations, seeds, test-sealed constraints, finiteness,
+ calculates every hard gate and numeric score, selects the winning candidate,
+ and returns a structured evaluator payload.
+ """
+ baseline_path = Path(baseline_path)
+ candidate_path = Path(candidate_path)
+
+ if not baseline_path.is_file():
+ raise FileNotFoundError(f"Baseline artifact not found at '{baseline_path}'")
+ if not candidate_path.is_file():
+ raise FileNotFoundError(f"Candidate artifact not found at '{candidate_path}'")
+
+ with open(baseline_path, "r", encoding="utf-8") as f:
+ baseline_data = json.load(f)
+
+ with open(candidate_path, "r", encoding="utf-8") as f:
+ candidate_data = json.load(f)
+
+ WORKLOAD_TOTAL_DIMS: Dict[str, int] = {
+ "mnist_compact": 9098,
+ "mnist_wide": 55338,
+ "fashion_compact": 9098,
+ "fashion_wide": 55338,
+ }
+
+ if (
+ baseline_data.get("official_test_data_loaded") is not False
+ or baseline_data.get("official_test_evaluations") != 0
+ ):
+ raise ValueError("Baseline artifact must explicitly seal official test data.")
+
+ # Validate baseline JSON schema & confirmation results
+ if "confirmation_results" not in baseline_data:
+ raise KeyError("Baseline JSON missing top-level 'confirmation_results' key")
+
+ baseline_confirm = baseline_data["confirmation_results"]
+ baseline_metrics: Dict[str, Dict[str, float]] = {}
+ baseline_core_bytes: Dict[str, int] = {}
+
+ for wl in EXPECTED_WORKLOADS:
+ if wl not in baseline_confirm:
+ raise KeyError(f"Baseline confirmation results missing workload '{wl}'")
+ selected_method = BASELINE_POLICY[wl]
+ if selected_method not in baseline_confirm[wl]:
+ raise KeyError(
+ f"Baseline confirmation results for '{wl}' missing policy method '{selected_method}'"
+ )
+ entry = baseline_confirm[wl][selected_method]
+ stats = entry.get("stats", {}) if isinstance(entry, dict) else {}
+ val_nll_mean = float(stats.get("val_nll", {}).get("mean", float("nan")))
+ val_acc_mean = float(stats.get("val_acc", {}).get("mean", float("nan")))
+ if not (math.isfinite(val_nll_mean) and math.isfinite(val_acc_mean)):
+ raise ValueError(f"Baseline metrics for '{wl}' method '{selected_method}' contain NaN or non-finite value")
+
+ baseline_metrics[wl] = {
+ "val_nll": val_nll_mean,
+ "val_acc": val_acc_mean,
+ "val_brier": float(stats.get("val_brier", {}).get("mean", 0.0) or 0.0),
+ "val_ece": float(stats.get("val_ece", {}).get("mean", 0.0) or 0.0),
+ "method_id": selected_method,
+ }
+
+ bytes_list = []
+ if (
+ isinstance(entry, dict)
+ and isinstance(entry.get("per_seed_runs"), list)
+ ):
+ bytes_list = [
+ int(run["core_swarm_state_bytes"])
+ for run in entry["per_seed_runs"]
+ if (
+ isinstance(run, dict)
+ and "core_swarm_state_bytes" in run
+ and math.isfinite(float(run["core_swarm_state_bytes"]))
+ )
+ ]
+ if bytes_list and len(set(bytes_list)) != 1:
+ raise ValueError(f"Baseline core-state bytes vary across seeds for '{wl}'.")
+ if bytes_list:
+ b_bytes = bytes_list[0]
+ else:
+ states = 5 * EXPECTED_PARTICLES + (1 if selected_method == "G8" else 0)
+ b_bytes = states * WORKLOAD_TOTAL_DIMS[wl] * 4
+ baseline_core_bytes[wl] = b_bytes
+
+ # Validate candidate JSON schema
+ if "candidate_runs" not in candidate_data:
+ raise KeyError("Candidate JSON missing top-level 'candidate_runs' key")
+
+ candidate_runs = candidate_data["candidate_runs"]
+ if not isinstance(candidate_runs, dict) or len(candidate_runs) == 0:
+ raise ValueError("Candidate JSON 'candidate_runs' must be a non-empty dictionary")
+
+ # Global candidate test-sealed checks
+ top_test_loaded_present = "official_test_data_loaded" in candidate_data
+ top_test_loaded_val = candidate_data.get("official_test_data_loaded")
+ top_test_evals_present = "official_test_evaluations" in candidate_data
+ top_test_evals_val = candidate_data.get("official_test_evaluations")
+
+ top_test_sealed = (
+ top_test_loaded_present
+ and top_test_loaded_val is False
+ and top_test_evals_present
+ and top_test_evals_val == 0
+ )
+
+ candidate_evaluations: Dict[str, Dict[str, Any]] = {}
+
+ for cand_id, wl_map in candidate_runs.items():
+ gate_finite = True
+ gate_test_sealed = bool(top_test_sealed)
+ gate_config_matched = True
+
+ if not isinstance(wl_map, dict):
+ gate_config_matched = False
+ gate_finite = False
+ wl_map = {}
+
+ if set(wl_map) != set(EXPECTED_WORKLOADS):
+ gate_config_matched = False
+
+ for wl in EXPECTED_WORKLOADS:
+ if wl not in wl_map:
+ gate_config_matched = False
+ gate_finite = False
+
+ derived_ratios: Dict[str, float] = {}
+ per_workload_deltas: Dict[str, Dict[str, float]] = {}
+ acc_regressions_valid = True
+ nll_regressions_valid = True
+
+ for wl in EXPECTED_WORKLOADS:
+ if wl not in wl_map or not isinstance(wl_map[wl], dict):
+ acc_regressions_valid = False
+ nll_regressions_valid = False
+ continue
+
+ wl_entry = wl_map[wl]
+ p_val = wl_entry.get("particles")
+ e_val = wl_entry.get("epochs")
+ sub_val = wl_entry.get("subset_size")
+ seeds_val = wl_entry.get("seeds")
+
+ if (
+ p_val != EXPECTED_PARTICLES
+ or e_val != EXPECTED_EPOCHS
+ or sub_val != EXPECTED_SUBSET_SIZE
+ or seeds_val != EXPECTED_SEEDS
+ ):
+ gate_config_matched = False
+
+ per_seed = wl_entry.get("per_seed_runs")
+ if not isinstance(per_seed, list) or len(per_seed) != len(EXPECTED_SEEDS):
+ gate_config_matched = False
+ gate_finite = False
+ actual_seeds = []
+ else:
+ actual_seeds = [
+ s_run.get("seed") for s_run in per_seed if isinstance(s_run, dict) and "seed" in s_run
+ ]
+ if actual_seeds != EXPECTED_SEEDS:
+ gate_config_matched = False
+
+ expected_queries = EXPECTED_PARTICLES * EXPECTED_EPOCHS
+ expected_samples = expected_queries * EXPECTED_SUBSET_SIZE
+ for s_run in per_seed:
+ if (
+ not isinstance(s_run, dict)
+ or s_run.get("total_queries") != expected_queries
+ or s_run.get("total_sample_evaluations") != expected_samples
+ ):
+ gate_config_matched = False
+
+ stats = wl_entry.get("stats") if isinstance(wl_entry.get("stats"), dict) else {}
+ val_nll_dict = stats.get("val_nll") if isinstance(stats.get("val_nll"), dict) else {}
+ val_acc_dict = stats.get("val_acc") if isinstance(stats.get("val_acc"), dict) else {}
+
+ c_nll_raw = val_nll_dict.get("mean")
+ c_acc_raw = val_acc_dict.get("mean")
+
+ if (
+ c_nll_raw is None
+ or c_acc_raw is None
+ or not isinstance(c_nll_raw, (int, float))
+ or not isinstance(c_acc_raw, (int, float))
+ or not (math.isfinite(float(c_nll_raw)) and math.isfinite(float(c_acc_raw)))
+ ):
+ gate_finite = False
+ c_nll = float("nan")
+ c_acc = float("nan")
+ else:
+ c_nll = float(c_nll_raw)
+ c_acc = float(c_acc_raw)
+
+ if isinstance(per_seed, list):
+ for s_run in per_seed:
+ if not isinstance(s_run, dict):
+ gate_finite = False
+ gate_config_matched = False
+ continue
+ if "official_test_evaluations" not in s_run or s_run["official_test_evaluations"] != 0:
+ gate_test_sealed = False
+ if s_run.get("is_finite") is not True:
+ gate_finite = False
+
+ s_nll = s_run.get("val_selected_loss")
+ s_acc = s_run.get("val_selected_acc")
+ g_nll = s_run.get("gbest_loss")
+ g_acc = s_run.get("gbest_acc")
+ w_time = s_run.get("wall_time_sec")
+ val_m = s_run.get("val_metrics")
+
+ val_m_ok = (
+ isinstance(val_m, dict)
+ and len(val_m) > 0
+ and all(
+ isinstance(v, (int, float)) and math.isfinite(float(v))
+ for v in val_m.values()
+ )
+ )
+
+ scalars_for_s_run = [s_nll, s_acc, g_nll, g_acc, w_time]
+ s_scalars_ok = all(
+ v is not None and isinstance(v, (int, float)) and math.isfinite(float(v))
+ for v in scalars_for_s_run
+ )
+
+ if not (val_m_ok and s_scalars_ok):
+ gate_finite = False
+
+ expected_total_dim = WORKLOAD_TOTAL_DIMS[wl]
+ total_dim = wl_entry.get("total_dim")
+ raw_ratio = wl_entry.get("ratio")
+ if (
+ total_dim != expected_total_dim
+ or not isinstance(raw_ratio, (int, float))
+ or not (0.0 < float(raw_ratio) <= 1.0)
+ ):
+ gate_config_matched = False
+ total_dim = expected_total_dim
+ raw_ratio = 1.0
+
+ latent_dim = compute_latent_dim(total_dim, float(raw_ratio))
+ if wl_entry.get("latent_dim") != latent_dim:
+ gate_config_matched = False
+
+ analytical_cand_bytes = compute_core_swarm_state_bytes(EXPECTED_PARTICLES, latent_dim)
+ b_bytes = baseline_core_bytes[wl]
+
+ derived_ratio = float(analytical_cand_bytes) / float(b_bytes)
+ derived_ratios[wl] = derived_ratio
+
+ if wl_entry.get("core_swarm_state_bytes") != analytical_cand_bytes:
+ gate_config_matched = False
+
+ if isinstance(per_seed, list):
+ for s_run in per_seed:
+ if isinstance(s_run, dict) and s_run.get("core_swarm_state_bytes") != analytical_cand_bytes:
+ gate_config_matched = False
+
+ reported_state_ratio = wl_entry.get("state_ratio")
+ if (
+ not isinstance(reported_state_ratio, (int, float))
+ or not math.isfinite(float(reported_state_ratio))
+ or not math.isclose(
+ float(reported_state_ratio),
+ derived_ratio,
+ rel_tol=1e-5,
+ abs_tol=1e-5,
+ )
+ ):
+ gate_config_matched = False
+
+ b_metrics = baseline_metrics[wl]
+ b_nll = b_metrics["val_nll"]
+ b_acc = b_metrics["val_acc"]
+
+ if math.isfinite(c_nll) and math.isfinite(c_acc) and math.isfinite(b_nll) and math.isfinite(b_acc):
+ nll_delta = c_nll - b_nll
+ rel_nll_reduction_pct = ((b_nll - c_nll) / b_nll) * 100.0 if b_nll > 0 else 0.0
+ acc_gain_pp = c_acc - b_acc
+
+ per_workload_deltas[wl] = {
+ "state_ratio": derived_ratio,
+ "baseline_nll": b_nll,
+ "candidate_nll": c_nll,
+ "nll_delta": nll_delta,
+ "rel_nll_reduction_pct": rel_nll_reduction_pct,
+ "baseline_acc": b_acc,
+ "candidate_acc": c_acc,
+ "acc_gain_pp": acc_gain_pp,
+ }
+
+ if acc_gain_pp < -1.0:
+ acc_regressions_valid = False
+ if rel_nll_reduction_pct < -5.0:
+ nll_regressions_valid = False
+ else:
+ acc_regressions_valid = False
+ nll_regressions_valid = False
+ gate_finite = False
+
+ if derived_ratios and len(derived_ratios) == len(EXPECTED_WORKLOADS):
+ max_state_ratio = max(derived_ratios.values())
+ else:
+ max_state_ratio = 1.0
+
+ gate_state_ratio = bool(0.0 < max_state_ratio <= 0.5 and math.isfinite(max_state_ratio))
+ gate_acc_regression = bool(acc_regressions_valid)
+ gate_nll_regression = bool(nll_regressions_valid)
+
+ if "mnist_wide" in per_workload_deltas:
+ mw_delta = per_workload_deltas["mnist_wide"]
+ mw_acc_gain = mw_delta["acc_gain_pp"]
+ mw_nll_red = mw_delta["rel_nll_reduction_pct"]
+ gate_baseline_worst_improvement = bool((mw_acc_gain >= 2.0) or (mw_nll_red >= 5.0))
+ else:
+ gate_baseline_worst_improvement = False
+
+ gates = {
+ "gate_finite": bool(gate_finite),
+ "gate_test_sealed": bool(gate_test_sealed),
+ "gate_config_matched": bool(gate_config_matched),
+ "gate_state_ratio": bool(gate_state_ratio),
+ "gate_acc_regression": bool(gate_acc_regression),
+ "gate_nll_regression": bool(gate_nll_regression),
+ "gate_baseline_worst_improvement": bool(gate_baseline_worst_improvement),
+ }
+
+ failed_gates = [g_name for g_name, g_pass in gates.items() if not g_pass]
+ failed_gate_count = len(failed_gates)
+ cand_pass = bool(failed_gate_count == 0)
+
+ if len(per_workload_deltas) == len(EXPECTED_WORKLOADS):
+ mean_rel_nll_reduction_pct = float(
+ sum(d["rel_nll_reduction_pct"] for d in per_workload_deltas.values())
+ / len(per_workload_deltas)
+ )
+ mean_acc_gain_pp = float(
+ sum(d["acc_gain_pp"] for d in per_workload_deltas.values())
+ / len(per_workload_deltas)
+ )
+ else:
+ mean_rel_nll_reduction_pct = 0.0
+ mean_acc_gain_pp = 0.0
+
+ if 0.0 < max_state_ratio <= 1.0 and math.isfinite(max_state_ratio):
+ state_efficiency_bonus = 10.0 * math.log2(1.0 / max_state_ratio)
+ else:
+ state_efficiency_bonus = 0.0
+
+ score = (
+ mean_rel_nll_reduction_pct
+ + mean_acc_gain_pp
+ + state_efficiency_bonus
+ - (100.0 * failed_gate_count)
+ )
+
+ if not math.isfinite(score):
+ score = -100.0 * max(1, failed_gate_count)
+
+ candidate_evaluations[cand_id] = {
+ "candidate_id": cand_id,
+ "pass": cand_pass,
+ "score": float(score),
+ "failed_gates": failed_gates,
+ "failed_gate_count": failed_gate_count,
+ "gate_details": gates,
+ "per_workload": per_workload_deltas,
+ "state_ratios": derived_ratios,
+ "summary_metrics": {
+ "mean_rel_nll_reduction_pct": mean_rel_nll_reduction_pct,
+ "mean_acc_gain_pp": mean_acc_gain_pp,
+ "max_state_ratio": max_state_ratio,
+ "state_efficiency_bonus": state_efficiency_bonus,
+ },
+ }
+
+ passing_cand_ids = [
+ c_id for c_id, c_eval in candidate_evaluations.items() if c_eval["pass"]
+ ]
+
+ if passing_cand_ids:
+ selected_candidate_id = max(
+ passing_cand_ids, key=lambda c_id: candidate_evaluations[c_id]["score"]
+ )
+ overall_pass = True
+ else:
+ selected_candidate_id = max(
+ candidate_evaluations.keys(),
+ key=lambda c_id: candidate_evaluations[c_id]["score"],
+ )
+ overall_pass = False
+
+ selected_eval = candidate_evaluations[selected_candidate_id]
+
+ evaluator_output = {
+ "pass": overall_pass,
+ "score": float(selected_eval["score"]),
+ "selected_candidate_id": selected_candidate_id,
+ "evaluator_version": EVALUATOR_VERSION,
+ "source_paths": {
+ "baseline_path": str(baseline_path),
+ "candidate_path": str(candidate_path),
+ },
+ "baseline_policy": BASELINE_POLICY,
+ "candidate_evaluations": candidate_evaluations,
+ "per_workload_deltas": selected_eval["per_workload"],
+ "state_ratios": selected_eval["state_ratios"],
+ }
+
+ if output_path is not None:
+ save_json_atomic(evaluator_output, Path(output_path))
+
+ return evaluator_output
+
+
+def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(
+ description="Strict Pareto Evaluator for Heavy Task PSO Autoresearch"
+ )
+ parser.add_argument(
+ "--baseline",
+ type=str,
+ default="benchmark_results/pso_v6_heavy_tasks.json",
+ help="Path to baseline heavy tasks JSON artifact",
+ )
+ parser.add_argument(
+ "--candidate",
+ type=str,
+ default=None,
+ help="Path to candidate heavy autoresearch JSON artifact",
+ )
+ parser.add_argument(
+ "candidate_pos",
+ nargs="?",
+ type=str,
+ default=None,
+ help="Positional candidate JSON path fallback",
+ )
+ parser.add_argument(
+ "--output",
+ type=str,
+ default=None,
+ help="Optional path to write evaluator result JSON",
+ )
+ return parser
+
+
+def main():
+ parser = build_parser()
+ args = parser.parse_args()
+
+ cand_path = args.candidate or args.candidate_pos
+ if not cand_path:
+ parser.error("Candidate JSON path must be supplied via --candidate or positional argument.")
+
+ out_path = Path(args.output) if args.output else None
+
+ result = evaluate_heavy_autoresearch(
+ baseline_path=args.baseline,
+ candidate_path=cand_path,
+ output_path=out_path,
+ )
+
+ print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/evaluate_heavy_cross_split.py b/test/evaluate_heavy_cross_split.py
new file mode 100644
index 0000000..4d0019c
--- /dev/null
+++ b/test/evaluate_heavy_cross_split.py
@@ -0,0 +1,741 @@
+"""Strict evaluator for the Heavy PSO cross-split robustness mission.
+
+Every candidate is compared with a baseline rerun on the same train/validation
+partition and swarm seeds. Official test data must remain sealed. Development
+may qualify a policy for one-shot confirmation, but mission ``pass`` is true
+only when both phases satisfy the frozen evaluator contract.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+from benchmark_suite import save_json_atomic
+from heavy_pso_autoresearch import compute_core_swarm_state_bytes, compute_latent_dim
+
+EVALUATOR_VERSION = "HEAVY-PSO-CROSS-SPLIT-EVALUATOR 1.0.0"
+EXPECTED_PARTICLES = 12
+EXPECTED_EPOCHS = 80
+EXPECTED_SUBSET_SIZE = 10000
+EXPECTED_QUERIES = EXPECTED_PARTICLES * EXPECTED_EPOCHS
+EXPECTED_SAMPLES = EXPECTED_QUERIES * EXPECTED_SUBSET_SIZE
+EXPECTED_DEV_SPLIT_SEEDS = [20260905, 20260906]
+EXPECTED_DEV_SWARM_SEEDS = [101, 102, 103]
+EXPECTED_CONF_SPLIT_SEEDS = [20260907]
+EXPECTED_CONF_SWARM_SEEDS = [111, 112, 113]
+WORKLOADS = ["mnist_compact", "mnist_wide", "fashion_compact", "fashion_wide"]
+BASELINE_METHODS = {
+ "mnist_compact": "G8",
+ "mnist_wide": "G5",
+ "fashion_compact": "G8",
+ "fashion_wide": "G5",
+}
+TOTAL_DIMS = {
+ "mnist_compact": 9098,
+ "mnist_wide": 55338,
+ "fashion_compact": 9098,
+ "fashion_wide": 55338,
+}
+PHASE_SPECS = {
+ "development": (EXPECTED_DEV_SPLIT_SEEDS, EXPECTED_DEV_SWARM_SEEDS),
+ "confirmation": (EXPECTED_CONF_SPLIT_SEEDS, EXPECTED_CONF_SWARM_SEEDS),
+}
+
+
+def load_artifact(path: Path) -> Dict[str, Any]:
+ if not path.is_file():
+ raise FileNotFoundError(f"Artifact file not found: {path}")
+ with path.open("r", encoding="utf-8") as handle:
+ data = json.load(handle)
+ if not isinstance(data, dict):
+ raise ValueError(f"Artifact at {path} must be a JSON object")
+ return data
+
+
+def _is_finite_number(value: Any) -> bool:
+ return (
+ isinstance(value, (int, float))
+ and not isinstance(value, bool)
+ and math.isfinite(float(value))
+ )
+
+
+def _mean(values: Sequence[float]) -> float:
+ return float(math.fsum(values) / len(values))
+
+
+def _append_issue(issues: Dict[str, List[str]], category: str, message: str) -> None:
+ issues[category].append(message)
+
+
+def _validate_stats(
+ entry: Dict[str, Any],
+ per_seed_runs: List[Dict[str, Any]],
+ label: str,
+ issues: Dict[str, List[str]],
+) -> Optional[Tuple[float, float]]:
+ stats = entry.get("stats")
+ if not isinstance(stats, dict):
+ _append_issue(issues, "schema", f"{label}: missing stats object")
+ return None
+
+ try:
+ acc_mean = stats["val_acc"]["mean"]
+ nll_mean = stats["val_nll"]["mean"]
+ except (KeyError, TypeError):
+ _append_issue(issues, "schema", f"{label}: missing val_acc/val_nll means")
+ return None
+
+ if not (_is_finite_number(acc_mean) and _is_finite_number(nll_mean)):
+ _append_issue(issues, "finite", f"{label}: non-finite aggregate metrics")
+ return None
+
+ if len(per_seed_runs) > 0:
+ run_accs: List[float] = []
+ run_nlls: List[float] = []
+ for run in per_seed_runs:
+ if not isinstance(run, dict):
+ continue
+ seed_label = f"{label}/seed={run.get('seed')}"
+
+ if "val_selected_acc" not in run or run.get("val_selected_acc") is None:
+ _append_issue(issues, "schema", f"{seed_label}: missing val_selected_acc")
+ else:
+ val_acc = run["val_selected_acc"]
+ if not isinstance(val_acc, (int, float)) or isinstance(val_acc, bool):
+ _append_issue(issues, "schema", f"{seed_label}: non-numeric val_selected_acc")
+ elif not math.isfinite(float(val_acc)):
+ _append_issue(issues, "finite", f"{seed_label}: non-finite val_selected_acc")
+ else:
+ run_accs.append(float(val_acc))
+
+ if "val_selected_loss" not in run or run.get("val_selected_loss") is None:
+ _append_issue(issues, "schema", f"{seed_label}: missing val_selected_loss")
+ else:
+ val_nll = run["val_selected_loss"]
+ if not isinstance(val_nll, (int, float)) or isinstance(val_nll, bool):
+ _append_issue(issues, "schema", f"{seed_label}: non-numeric val_selected_loss")
+ elif not math.isfinite(float(val_nll)):
+ _append_issue(issues, "finite", f"{seed_label}: non-finite val_selected_loss")
+ else:
+ run_nlls.append(float(val_nll))
+
+ if len(run_accs) == len(per_seed_runs):
+ if not math.isclose(float(acc_mean), _mean(run_accs), rel_tol=1e-6, abs_tol=1e-5):
+ _append_issue(issues, "schema", f"{label}: val_acc mean disagrees with per-seed runs")
+ if len(run_nlls) == len(per_seed_runs):
+ if not math.isclose(float(nll_mean), _mean(run_nlls), rel_tol=1e-6, abs_tol=1e-5):
+ _append_issue(issues, "schema", f"{label}: val_nll mean disagrees with per-seed runs")
+ return float(acc_mean), float(nll_mean)
+
+
+def _validate_runs(
+ entry: Dict[str, Any],
+ expected_seeds: List[int],
+ expected_state_bytes: int,
+ label: str,
+ candidate: bool,
+ issues: Dict[str, List[str]],
+) -> Tuple[List[Dict[str, Any]], int, int]:
+ runs = entry.get("per_seed_runs")
+ if not isinstance(runs, list) or len(runs) != len(expected_seeds):
+ _append_issue(issues, "schema", f"{label}: expected {len(expected_seeds)} per-seed runs")
+ return [], 0, 0
+
+ if [run.get("seed") if isinstance(run, dict) else None for run in runs] != expected_seeds:
+ _append_issue(issues, "config", f"{label}: per-seed run order/content does not match {expected_seeds}")
+
+ total_queries = 0
+ total_samples = 0
+ numeric_fields = (
+ "val_selected_loss",
+ "val_selected_acc",
+ "gbest_loss",
+ "gbest_acc",
+ "wall_time_sec",
+ "optimization_wall_time_sec",
+ "validation_wall_time_sec",
+ "throughput_samples_per_sec",
+ )
+
+ valid_runs: List[Dict[str, Any]] = []
+ for run in runs:
+ if not isinstance(run, dict):
+ _append_issue(issues, "schema", f"{label}: non-object seed record")
+ continue
+ seed_label = f"{label}/seed={run.get('seed')}"
+ for field in numeric_fields:
+ if not _is_finite_number(run.get(field)):
+ _append_issue(issues, "finite", f"{seed_label}: missing/non-finite {field}")
+
+ val_metrics = run.get("val_metrics")
+ if (
+ not isinstance(val_metrics, dict)
+ or not val_metrics
+ or any(not _is_finite_number(value) for value in val_metrics.values())
+ ):
+ _append_issue(issues, "finite", f"{seed_label}: missing/non-finite val_metrics")
+
+ if run.get("official_test_evaluations") != 0:
+ _append_issue(issues, "test", f"{seed_label}: official_test_evaluations must be 0")
+ if candidate and run.get("is_finite") is not True:
+ _append_issue(issues, "finite", f"{seed_label}: candidate is_finite must be true")
+ if run.get("total_queries") != EXPECTED_QUERIES:
+ _append_issue(issues, "accounting", f"{seed_label}: total_queries must be {EXPECTED_QUERIES}")
+ if run.get("total_sample_evaluations") != EXPECTED_SAMPLES:
+ _append_issue(issues, "accounting", f"{seed_label}: total_sample_evaluations must be {EXPECTED_SAMPLES}")
+ if run.get("core_swarm_state_bytes") != expected_state_bytes:
+ _append_issue(issues, "state", f"{seed_label}: incorrect core_swarm_state_bytes")
+
+ if isinstance(run.get("total_queries"), int):
+ total_queries += run["total_queries"]
+ if isinstance(run.get("total_sample_evaluations"), int):
+ total_samples += run["total_sample_evaluations"]
+ valid_runs.append(run)
+
+ return valid_runs, total_queries, total_samples
+
+
+def _validate_artifact(artifact: Dict[str, Any], phase: str) -> Dict[str, Any]:
+ expected_splits, expected_seeds = PHASE_SPECS[phase]
+ issues: Dict[str, List[str]] = {
+ "schema": [],
+ "test": [],
+ "finite": [],
+ "provenance": [],
+ "config": [],
+ "accounting": [],
+ "state": [],
+ }
+ cells: List[Dict[str, Any]] = []
+ state_ratios: Dict[str, float] = {}
+ expected_split_keys = {str(seed) for seed in expected_splits}
+
+ if not isinstance(artifact, dict):
+ _append_issue(issues, "schema", f"{phase}: artifact must be an object")
+ return {
+ "issues": issues,
+ "cells": cells,
+ "state_ratios": state_ratios,
+ "max_state_ratio": 1.0,
+ "policy_signature": None,
+ }
+
+ if artifact.get("phase") != phase:
+ _append_issue(issues, "schema", f"{phase}: phase field mismatch")
+ if artifact.get("split_seeds") != expected_splits:
+ _append_issue(issues, "config", f"{phase}: split_seeds must be {expected_splits}")
+ if artifact.get("swarm_seeds") != expected_seeds:
+ _append_issue(issues, "config", f"{phase}: swarm_seeds must be {expected_seeds}")
+ if artifact.get("official_test_data_loaded") is not False:
+ _append_issue(issues, "test", f"{phase}: official_test_data_loaded must be false")
+ if artifact.get("official_test_evaluations") != 0:
+ _append_issue(issues, "test", f"{phase}: official_test_evaluations must be 0")
+
+ candidate_config = artifact.get("candidate_config")
+ if not isinstance(candidate_config, dict):
+ _append_issue(issues, "schema", f"{phase}: missing candidate_config")
+ candidate_config = {}
+ for field, expected in (
+ ("particles", EXPECTED_PARTICLES),
+ ("epochs", EXPECTED_EPOCHS),
+ ("subset_size", EXPECTED_SUBSET_SIZE),
+ ):
+ if candidate_config.get(field) != expected:
+ _append_issue(issues, "config", f"{phase}: candidate_config.{field} must be {expected}")
+
+ workload_config = artifact.get("workloads")
+ if not isinstance(workload_config, dict) or set(workload_config) != set(WORKLOADS):
+ _append_issue(issues, "schema", f"{phase}: workloads metadata must contain exactly {WORKLOADS}")
+ workload_config = {}
+
+ splits = artifact.get("splits")
+ if not isinstance(splits, dict) or set(splits) != expected_split_keys:
+ _append_issue(issues, "schema", f"{phase}: splits must contain exactly {sorted(expected_split_keys)}")
+ splits = splits if isinstance(splits, dict) else {}
+
+ observed_runs = 0
+ observed_queries = 0
+ observed_samples = 0
+
+ for split_seed in expected_splits:
+ split_key = str(split_seed)
+ split_entry = splits.get(split_key)
+ if not isinstance(split_entry, dict):
+ _append_issue(issues, "schema", f"{phase}/{split_key}: missing split object")
+ continue
+ if split_entry.get("split_seed") != split_seed:
+ _append_issue(issues, "provenance", f"{phase}/{split_key}: split_seed mismatch")
+
+ baselines = split_entry.get("baselines")
+ candidates = split_entry.get("candidates")
+ if not isinstance(baselines, dict) or set(baselines) != set(WORKLOADS):
+ _append_issue(issues, "schema", f"{phase}/{split_key}: baseline workloads incomplete")
+ baselines = baselines if isinstance(baselines, dict) else {}
+ if not isinstance(candidates, dict) or set(candidates) != set(WORKLOADS):
+ _append_issue(issues, "schema", f"{phase}/{split_key}: candidate workloads incomplete")
+ candidates = candidates if isinstance(candidates, dict) else {}
+
+ for workload in WORKLOADS:
+ baseline = baselines.get(workload)
+ candidate_entry = candidates.get(workload)
+ label = f"{phase}/{split_key}/{workload}"
+ if not isinstance(baseline, dict) or not isinstance(candidate_entry, dict):
+ _append_issue(issues, "schema", f"{label}: missing baseline or candidate entry")
+ continue
+
+ if baseline.get("method_id") != BASELINE_METHODS[workload]:
+ _append_issue(issues, "config", f"{label}: wrong baseline method")
+ for mode, entry in (("baseline", baseline), ("candidate", candidate_entry)):
+ if entry.get("workload_id") != workload:
+ _append_issue(issues, "schema", f"{label}/{mode}: workload_id mismatch")
+ if entry.get("split_seed") != split_seed:
+ _append_issue(issues, "provenance", f"{label}/{mode}: split_seed mismatch")
+ if entry.get("particles") != EXPECTED_PARTICLES:
+ _append_issue(issues, "config", f"{label}/{mode}: particles mismatch")
+ if entry.get("epochs") != EXPECTED_EPOCHS:
+ _append_issue(issues, "config", f"{label}/{mode}: epochs mismatch")
+ if entry.get("subset_size") != EXPECTED_SUBSET_SIZE:
+ _append_issue(issues, "config", f"{label}/{mode}: subset_size mismatch")
+ if entry.get("seeds") != expected_seeds:
+ _append_issue(issues, "config", f"{label}/{mode}: seeds mismatch")
+
+ fingerprints = (
+ baseline.get("split_fingerprint"),
+ candidate_entry.get("split_fingerprint"),
+ baseline.get("data_fingerprint"),
+ candidate_entry.get("data_fingerprint"),
+ )
+ if any(not isinstance(value, str) or not value for value in fingerprints):
+ _append_issue(issues, "provenance", f"{label}: fingerprints must be non-empty strings")
+ elif fingerprints[0] != fingerprints[1] or fingerprints[2] != fingerprints[3]:
+ _append_issue(issues, "provenance", f"{label}: baseline/candidate fingerprints differ")
+
+ total_dim = TOTAL_DIMS[workload]
+ baseline_states = 5 * EXPECTED_PARTICLES + (1 if BASELINE_METHODS[workload] == "G8" else 0)
+ expected_baseline_bytes = baseline_states * total_dim * 4
+ raw_ratio = candidate_entry.get("ratio")
+ if not _is_finite_number(raw_ratio) or not (0.0 < float(raw_ratio) <= 1.0):
+ _append_issue(issues, "state", f"{label}: invalid candidate ratio")
+ expected_candidate_bytes = -1
+ else:
+ expected_latent_dim = compute_latent_dim(total_dim, float(raw_ratio))
+ expected_candidate_bytes = compute_core_swarm_state_bytes(EXPECTED_PARTICLES, expected_latent_dim)
+ if candidate_entry.get("total_dim") != total_dim:
+ _append_issue(issues, "state", f"{label}: total_dim mismatch")
+ if candidate_entry.get("latent_dim") != expected_latent_dim:
+ _append_issue(issues, "state", f"{label}: latent_dim mismatch")
+ if candidate_entry.get("core_swarm_state_bytes") != expected_candidate_bytes:
+ _append_issue(issues, "state", f"{label}: candidate state bytes mismatch")
+ if candidate_entry.get("baseline_core_swarm_state_bytes") != expected_baseline_bytes:
+ _append_issue(issues, "state", f"{label}: candidate baseline state bytes mismatch")
+ ratio = expected_candidate_bytes / expected_baseline_bytes
+ state_ratios[workload] = max(state_ratios.get(workload, 0.0), ratio)
+ if not _is_finite_number(candidate_entry.get("state_ratio")) or not math.isclose(
+ float(candidate_entry.get("state_ratio", -1.0)), ratio, rel_tol=1e-6, abs_tol=1e-6
+ ):
+ _append_issue(issues, "state", f"{label}: reported state_ratio mismatch")
+
+ baseline_runs, b_queries, b_samples = _validate_runs(
+ baseline,
+ expected_seeds,
+ expected_baseline_bytes,
+ f"{label}/baseline",
+ False,
+ issues,
+ )
+ candidate_runs, c_queries, c_samples = _validate_runs(
+ candidate_entry,
+ expected_seeds,
+ expected_candidate_bytes,
+ f"{label}/candidate",
+ True,
+ issues,
+ )
+ observed_runs += len(baseline_runs) + len(candidate_runs)
+ observed_queries += b_queries + c_queries
+ observed_samples += b_samples + c_samples
+
+ baseline_stats = _validate_stats(baseline, baseline_runs, f"{label}/baseline", issues)
+ candidate_stats = _validate_stats(candidate_entry, candidate_runs, f"{label}/candidate", issues)
+ if baseline_stats is not None and candidate_stats is not None:
+ baseline_acc, baseline_nll = baseline_stats
+ candidate_acc, candidate_nll = candidate_stats
+ nll_reduction = (
+ (baseline_nll - candidate_nll) / baseline_nll
+ if baseline_nll > 0.0
+ else float("nan")
+ )
+ if not math.isfinite(nll_reduction):
+ _append_issue(issues, "finite", f"{label}: NLL reduction is non-finite")
+ else:
+ cells.append(
+ {
+ "phase": phase,
+ "split_seed": split_seed,
+ "workload_id": workload,
+ "baseline_acc": baseline_acc,
+ "candidate_acc": candidate_acc,
+ "baseline_nll": baseline_nll,
+ "candidate_nll": candidate_nll,
+ "acc_gain_pp": candidate_acc - baseline_acc,
+ "nll_reduction_fraction": nll_reduction,
+ }
+ )
+
+ expected_runs = len(expected_splits) * len(WORKLOADS) * len(expected_seeds) * 2
+ if observed_runs != expected_runs:
+ _append_issue(issues, "accounting", f"{phase}: observed {observed_runs} runs, expected {expected_runs}")
+ resources = artifact.get("resource_totals")
+ if not isinstance(resources, dict):
+ _append_issue(issues, "accounting", f"{phase}: missing resource_totals")
+ resources = {}
+ if resources.get("total_runs") != observed_runs:
+ _append_issue(issues, "accounting", f"{phase}: total_runs does not match records")
+ if resources.get("total_queries") != observed_queries:
+ _append_issue(issues, "accounting", f"{phase}: total_queries does not match records")
+ if resources.get("total_samples_evaluated") != observed_samples:
+ _append_issue(issues, "accounting", f"{phase}: total_samples_evaluated does not match records")
+ if resources.get("official_test_evaluations") != 0:
+ _append_issue(issues, "test", f"{phase}: resource official_test_evaluations must be 0")
+
+ max_state_ratio = max(state_ratios.values(), default=1.0)
+ policy_signature = {
+ "candidate_config": candidate_config,
+ "workloads": workload_config,
+ }
+ return {
+ "issues": issues,
+ "cells": cells,
+ "state_ratios": state_ratios,
+ "max_state_ratio": max_state_ratio,
+ "policy_signature": policy_signature,
+ }
+
+
+def evaluate_heavy_cross_split(
+ development_artifact: Dict[str, Any],
+ confirmation_artifact: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+ dev_result = _validate_artifact(development_artifact, "development")
+ conf_result = (
+ _validate_artifact(confirmation_artifact, "confirmation")
+ if confirmation_artifact is not None
+ else None
+ )
+
+ gates: Dict[str, Dict[str, Any]] = {}
+ failed_gates: List[str] = []
+ development_gate_names: List[str] = []
+
+ def record_gate(
+ name: str,
+ passed: bool,
+ observed: Any,
+ expected: Any,
+ details: str,
+ development_gate: bool = False,
+ ) -> None:
+ gates[name] = {
+ "pass": bool(passed),
+ "observed": observed,
+ "expected": expected,
+ "details": details,
+ }
+ if not passed:
+ failed_gates.append(name)
+ if development_gate:
+ development_gate_names.append(name)
+
+ all_results = [dev_result] + ([conf_result] if conf_result is not None else [])
+ record_gate(
+ "schema_and_phase_seeds",
+ all(not result["issues"]["schema"] for result in all_results),
+ [message for result in all_results for message in result["issues"]["schema"]][:10],
+ "complete artifacts with exact declared phase/split/swarm seeds",
+ "Missing evidence is rejected rather than defaulted",
+ True,
+ )
+ record_gate(
+ "official_test_sealed",
+ all(not result["issues"]["test"] for result in all_results),
+ [message for result in all_results for message in result["issues"]["test"]][:10],
+ "loaded=false and evaluations=0 at artifact, resource, and run levels",
+ "Official test data must never be loaded or evaluated",
+ True,
+ )
+ record_gate(
+ "all_runs_finite",
+ all(not result["issues"]["finite"] for result in all_results),
+ [message for result in all_results for message in result["issues"]["finite"]][:10],
+ "all aggregate and per-run validation metrics and times finite",
+ "Every recorded validation metric must be finite",
+ True,
+ )
+ record_gate(
+ "split_and_fingerprint_matched",
+ all(not result["issues"]["provenance"] for result in all_results),
+ [message for result in all_results for message in result["issues"]["provenance"]][:10],
+ "non-empty matching split/data fingerprints and split seeds per baseline/candidate cell",
+ "Every delta must use a baseline rerun on the identical partition",
+ True,
+ )
+
+ policy_matches = conf_result is None or (
+ dev_result["policy_signature"] == conf_result["policy_signature"]
+ )
+ config_issues = [message for result in all_results for message in result["issues"]["config"]]
+ if not policy_matches:
+ config_issues.append("confirmation candidate policy differs from the frozen development policy")
+ record_gate(
+ "configuration_and_policy_matched",
+ not config_issues,
+ config_issues[:10],
+ "12p x 80e x fixed10k, exact seeds, matching baseline, identical frozen candidate policy",
+ "Confirmation cannot change the development-selected policy",
+ True,
+ )
+ record_gate(
+ "query_and_sample_accounting_exact",
+ all(not result["issues"]["accounting"] for result in all_results),
+ [message for result in all_results for message in result["issues"]["accounting"]][:10],
+ f"{EXPECTED_QUERIES} queries and {EXPECTED_SAMPLES} sample evaluations per run",
+ "Per-run and aggregate accounting must agree exactly",
+ True,
+ )
+
+ max_state_ratio = max(result["max_state_ratio"] for result in all_results)
+ state_issues = [message for result in all_results for message in result["issues"]["state"]]
+ state_ok = not state_issues and 0.0 < max_state_ratio <= 0.5 + 1e-12
+ record_gate(
+ "maximum_state_ratio_each_workload",
+ state_ok,
+ {"max_state_ratio": max_state_ratio, "issues": state_issues[:10]},
+ "analytically verified state ratio <= 0.5 for every cell",
+ "No absent or reported-only state evidence is accepted",
+ True,
+ )
+
+ dev_cells = dev_result["cells"]
+ conf_cells = conf_result["cells"] if conf_result is not None else []
+ all_cells = dev_cells + conf_cells
+ expected_dev_cells = len(EXPECTED_DEV_SPLIT_SEEDS) * len(WORKLOADS)
+ complete_dev_cells = len(dev_cells) == expected_dev_cells
+
+ def nonregression(cells: List[Dict[str, Any]]) -> Tuple[bool, float, float]:
+ if not cells:
+ return False, float("inf"), float("inf")
+ max_acc_regression = max(-cell["acc_gain_pp"] for cell in cells)
+ max_nll_regression = max(-cell["nll_reduction_fraction"] for cell in cells)
+ return (
+ max_acc_regression <= 1.0 + 1e-12 and max_nll_regression <= 0.05 + 1e-12,
+ max_acc_regression,
+ max_nll_regression,
+ )
+
+ all_nonreg, max_acc_reg, max_nll_reg = nonregression(all_cells)
+ record_gate(
+ "maximum_accuracy_regression_percentage_points_each_split_workload",
+ bool(all_cells) and max_acc_reg <= 1.0 + 1e-12,
+ max_acc_reg,
+ "<= 1.0 pp",
+ "No evaluated split-workload cell may regress accuracy by more than 1 pp",
+ True,
+ )
+ record_gate(
+ "maximum_nll_regression_fraction_each_split_workload",
+ bool(all_cells) and max_nll_reg <= 0.05 + 1e-12,
+ max_nll_reg,
+ "<= 0.05",
+ "No evaluated split-workload cell may regress NLL by more than 5%",
+ True,
+ )
+ dev_nonreg, dev_acc_reg, dev_nll_reg = nonregression(dev_cells)
+
+ dev_acc_mean = _mean([cell["acc_gain_pp"] for cell in dev_cells]) if dev_cells else float("-inf")
+ dev_nll_mean = _mean([cell["nll_reduction_fraction"] for cell in dev_cells]) if dev_cells else float("-inf")
+ record_gate(
+ "development_grand_mean_accuracy_gain_minimum_pp",
+ complete_dev_cells and dev_acc_mean >= 0.0,
+ dev_acc_mean,
+ ">= 0.0 pp",
+ "Development grand mean accuracy must not regress",
+ True,
+ )
+ record_gate(
+ "development_grand_mean_nll_reduction_minimum_fraction",
+ complete_dev_cells and dev_nll_mean >= 0.0,
+ dev_nll_mean,
+ ">= 0.0",
+ "Development grand mean NLL must not regress",
+ True,
+ )
+
+ dev_mw = [cell for cell in dev_cells if cell["workload_id"] == "mnist_wide"]
+ dev_mw_acc = _mean([cell["acc_gain_pp"] for cell in dev_mw]) if dev_mw else float("-inf")
+ dev_mw_nll = _mean([cell["nll_reduction_fraction"] for cell in dev_mw]) if dev_mw else float("-inf")
+ record_gate(
+ "development_mnist_wide_improvement",
+ len(dev_mw) == len(EXPECTED_DEV_SPLIT_SEEDS) and (dev_mw_acc >= 2.0 or dev_mw_nll >= 0.05),
+ {"accuracy_gain_pp": dev_mw_acc, "nll_reduction_fraction": dev_mw_nll},
+ "mean accuracy gain >=2pp OR mean NLL reduction >=5%",
+ "The prior worst baseline workload must materially improve across development partitions",
+ True,
+ )
+
+ development_pass = (
+ all(not messages for messages in dev_result["issues"].values())
+ and 0.0 < dev_result["max_state_ratio"] <= 0.5 + 1e-12
+ and complete_dev_cells
+ and dev_nonreg
+ and dev_acc_mean >= 0.0
+ and dev_nll_mean >= 0.0
+ and len(dev_mw) == len(EXPECTED_DEV_SPLIT_SEEDS)
+ and (dev_mw_acc >= 2.0 or dev_mw_nll >= 0.05)
+ )
+ if confirmation_artifact is None:
+ record_gate(
+ "confirmation_executed",
+ False,
+ "not executed",
+ "one exact confirmation artifact after development_pass",
+ "A development pass only qualifies the frozen policy for one-shot confirmation",
+ )
+ else:
+ record_gate(
+ "confirmation_executed",
+ True,
+ {"split_seeds": confirmation_artifact.get("split_seeds"), "swarm_seeds": confirmation_artifact.get("swarm_seeds")},
+ {"split_seeds": EXPECTED_CONF_SPLIT_SEEDS, "swarm_seeds": EXPECTED_CONF_SWARM_SEEDS},
+ "Confirmation evidence is evaluated only with the exact sealed phase contract",
+ )
+
+ expected_conf_cells = len(EXPECTED_CONF_SPLIT_SEEDS) * len(WORKLOADS)
+ complete_conf_cells = len(conf_cells) == expected_conf_cells
+ conf_nonreg, conf_acc_reg, conf_nll_reg = nonregression(conf_cells)
+ record_gate(
+ "confirmation_per_cell_non_regression",
+ complete_conf_cells and conf_nonreg,
+ {"cells": len(conf_cells), "max_acc_regression_pp": conf_acc_reg, "max_nll_regression_fraction": conf_nll_reg},
+ "4 cells; accuracy regression <=1pp and NLL regression <=5% in each",
+ "The sealed partition must remain safe workload by workload",
+ )
+
+ conf_acc_mean = _mean([cell["acc_gain_pp"] for cell in conf_cells]) if conf_cells else float("-inf")
+ conf_nll_mean = _mean([cell["nll_reduction_fraction"] for cell in conf_cells]) if conf_cells else float("-inf")
+ record_gate(
+ "confirmation_grand_mean_accuracy_gain_minimum_pp",
+ complete_conf_cells and conf_acc_mean >= 1.5,
+ conf_acc_mean,
+ ">= 1.5 pp",
+ "One-shot confirmation must retain the predeclared accuracy effect",
+ )
+ record_gate(
+ "confirmation_grand_mean_nll_reduction_minimum_fraction",
+ complete_conf_cells and conf_nll_mean >= 0.02,
+ conf_nll_mean,
+ ">= 0.02",
+ "One-shot confirmation must retain the predeclared NLL effect",
+ )
+
+ conf_mw = [cell for cell in conf_cells if cell["workload_id"] == "mnist_wide"]
+ conf_mw_acc = _mean([cell["acc_gain_pp"] for cell in conf_mw]) if conf_mw else float("-inf")
+ conf_mw_nll = _mean([cell["nll_reduction_fraction"] for cell in conf_mw]) if conf_mw else float("-inf")
+ record_gate(
+ "confirmation_mnist_wide_improvement",
+ len(conf_mw) == 1 and (conf_mw_acc >= 1.0 or conf_mw_nll >= 0.03),
+ {"accuracy_gain_pp": conf_mw_acc, "nll_reduction_fraction": conf_mw_nll},
+ "accuracy gain >=1pp OR NLL reduction >=3%",
+ "The prior worst workload must improve on the sealed partition",
+ )
+
+ combined_mw = dev_mw + conf_mw
+ combined_mw_acc = _mean([cell["acc_gain_pp"] for cell in combined_mw]) if combined_mw else float("-inf")
+ combined_mw_nll = _mean([cell["nll_reduction_fraction"] for cell in combined_mw]) if combined_mw else float("-inf")
+ record_gate(
+ "combined_mnist_wide_improvement",
+ len(combined_mw) == 3 and (combined_mw_acc >= 2.0 or combined_mw_nll >= 0.05),
+ {"accuracy_gain_pp": combined_mw_acc, "nll_reduction_fraction": combined_mw_nll},
+ "three-split mean accuracy gain >=2pp OR NLL reduction >=5%",
+ "The material worst-workload improvement must hold across all new partitions",
+ )
+
+ score_cells = all_cells if confirmation_artifact is not None else dev_cells
+ mean_acc_gain = _mean([cell["acc_gain_pp"] for cell in score_cells]) if score_cells else 0.0
+ mean_nll_reduction = _mean([cell["nll_reduction_fraction"] for cell in score_cells]) if score_cells else 0.0
+ score_gate_names = list(gates) if confirmation_artifact is not None else development_gate_names
+ score_failed_gates = sum(not gates[name]["pass"] for name in score_gate_names)
+ state_points = 10.0 * math.log2(1.0 / max_state_ratio) if 0.0 < max_state_ratio <= 1.0 else 0.0
+ score = (
+ 100.0 * mean_nll_reduction
+ + mean_acc_gain
+ + state_points
+ - 100.0 * score_failed_gates
+ )
+ mission_pass = confirmation_artifact is not None and not failed_gates
+
+ return {
+ "pass": bool(mission_pass),
+ "development_pass": bool(development_pass),
+ "eligible_for_confirmation": bool(development_pass and confirmation_artifact is None),
+ "score": float(score),
+ "evaluator_version": EVALUATOR_VERSION,
+ "failed_hard_gate_count": len(failed_gates),
+ "failed_gates": failed_gates,
+ "score_failed_gate_count": score_failed_gates,
+ "gates": gates,
+ "score_components": {
+ "mean_relative_nll_reduction_pct": 100.0 * mean_nll_reduction,
+ "mean_accuracy_gain_pp": mean_acc_gain,
+ "state_efficiency_points": state_points,
+ "gate_penalty_points": 100.0 * score_failed_gates,
+ "max_state_ratio": max_state_ratio,
+ },
+ "summary_metrics": {
+ "development_cells": len(dev_cells),
+ "confirmation_cells": len(conf_cells),
+ "development_grand_mean_accuracy_gain_pp": dev_acc_mean,
+ "development_grand_mean_nll_reduction_fraction": dev_nll_mean,
+ "development_mnist_wide_accuracy_gain_pp": dev_mw_acc,
+ "development_mnist_wide_nll_reduction_fraction": dev_mw_nll,
+ },
+ "cell_metrics": all_cells,
+ "state_ratios": {
+ "development": dev_result["state_ratios"],
+ "confirmation": conf_result["state_ratios"] if conf_result is not None else None,
+ },
+ }
+
+
+def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(description="Strict Heavy PSO cross-split evaluator")
+ parser.add_argument("--development", required=True, help="Development artifact JSON")
+ parser.add_argument("--confirmation", default=None, help="Optional one-shot confirmation artifact JSON")
+ parser.add_argument("--output", default=None, help="Optional evaluation JSON output")
+ return parser
+
+
+def main() -> None:
+ args = build_parser().parse_args()
+ development = load_artifact(Path(args.development))
+ confirmation = load_artifact(Path(args.confirmation)) if args.confirmation else None
+ result = evaluate_heavy_cross_split(development, confirmation)
+ if args.output:
+ save_json_atomic(result, Path(args.output))
+ print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/evaluate_post_training_ensemble.py b/test/evaluate_post_training_ensemble.py
new file mode 100644
index 0000000..370a5f2
--- /dev/null
+++ b/test/evaluate_post_training_ensemble.py
@@ -0,0 +1,1066 @@
+"""Strict Evaluator for Post-Training PSO Ensemble Study.
+
+Evaluates experiment artifacts against the frozen mission and evaluator contract
+defined in .omc/autoresearch/post-training-pso-ensemble/evaluator.json and mission.md.
+
+Recomputes 14 development hard gates and 9 confirmation hard gates, verifies
+leakage control, frozen-policy consistency, exact query/sample/cache accounting,
+simplex probability weight constraints, SLSQP solver status, finiteness, and metric consistency.
+
+Produces a structured evaluation payload containing score, pass/fail status, gate
+results, and issue categories. Never trusts self-reported artifact pass flags.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+EVALUATOR_VERSION = "POST-TRAINING-PSO-ENSEMBLE-EVALUATOR 1.2.0"
+EXPECTED_PROTOCOL_VERSION = "POST-TRAINING-PSO-ENSEMBLE 1.1.0"
+EXPECTED_DATASETS = ["mnist", "fashion_mnist"]
+EXPECTED_SPLIT_SEED = 20260904
+EXPECTED_SEARCH_SAMPLES = 50000
+EXPECTED_VAL_SAMPLES = 10000
+EXPECTED_POOL_SEEDS = [201, 202, 203, 204, 205]
+EXPECTED_REF_SINGLE_SEED = 201
+EXPECTED_50E_SINGLE_EPOCHS = 50
+EXPECTED_SWARM_SEEDS = [301, 302, 303]
+EXPECTED_PARTICLES = 30
+EXPECTED_EPOCHS = 30
+EXPECTED_QUERIES_PER_SEED = 900
+EXPECTED_SAMPLES_PER_SEED = 9000000
+
+REQUIRED_BASELINES = [
+ "reference_single_10e",
+ "best_single_10e",
+ "single_50e",
+ "uniform_ensemble",
+ "uniform_temperature",
+ "slsqp_weights",
+ "pso_weights",
+]
+REQUIRED_BASELINES_SET = set(REQUIRED_BASELINES)
+
+# Weighted methods that store explicit simplex weight vectors
+WEIGHTED_METHODS = [
+ "slsqp_weights",
+ "pso_weights",
+]
+
+
+def _is_finite_number(value: Any) -> bool:
+ """Returns True if value is a numeric int/float (not bool) and finite."""
+ return (
+ isinstance(value, (int, float))
+ and not isinstance(value, bool)
+ and math.isfinite(float(value))
+ )
+
+
+def _append_issue(issues: Dict[str, List[str]], category: str, message: str) -> None:
+ """Appends an issue string to the given category list."""
+ if category not in issues:
+ issues[category] = []
+ issues[category].append(message)
+
+
+def save_json_atomic(data: Dict[str, Any], json_path: Union[str, Path]) -> None:
+ """Atomically writes JSON payload to destination path using a temporary file."""
+ path = Path(json_path)
+ path.parent.mkdir(parents=True, exist_ok=True)
+ tmp_path = path.with_suffix(f".tmp_{os.getpid()}_{time.time_ns()}")
+ with open(tmp_path, "w", encoding="utf-8") as f:
+ json.dump(data, f, indent=2)
+ tmp_path.replace(path)
+
+
+def _to_pp(acc: float) -> float:
+ """Converts accuracy to percentage points (0-100 scale)."""
+ return acc * 100.0 if acc <= 1.0 else acc
+
+
+def _unwrap_metrics(entry: Any) -> Tuple[Optional[float], Optional[float]]:
+ """Unwraps accuracy and NLL/loss from base method dict or nested weighted method metrics dict."""
+ if not isinstance(entry, dict):
+ return None, None
+ metrics_dict = entry.get("metrics") if isinstance(entry.get("metrics"), dict) else entry
+
+ acc = None
+ for key in ("accuracy", "acc", "val_acc", "test_acc", "val_selected_acc"):
+ if key in metrics_dict and _is_finite_number(metrics_dict[key]):
+ acc = float(metrics_dict[key])
+ break
+
+ nll = None
+ for key in ("nll", "loss", "val_nll", "test_nll", "val_loss", "val_selected_loss"):
+ if key in metrics_dict and _is_finite_number(metrics_dict[key]):
+ nll = float(metrics_dict[key])
+ break
+
+ return acc, nll
+
+
+def _validate_simplex_weights(weights: Any, tolerance: float = 1e-6) -> bool:
+ """Validates that weights form a 5-element probability simplex summing to 1 within tolerance."""
+ if not isinstance(weights, (list, tuple)) or len(weights) != 5:
+ return False
+ for w in weights:
+ if not _is_finite_number(w) or float(w) < -tolerance:
+ return False
+ total = math.fsum([float(w) for w in weights])
+ return abs(total - 1.0) <= tolerance
+
+def _sequences_close(left: Any, right: Any, tolerance: float = 1e-6) -> bool:
+ """Return whether two finite numeric sequences agree elementwise."""
+ if not isinstance(left, (list, tuple)) or not isinstance(right, (list, tuple)):
+ return False
+ if len(left) != len(right):
+ return False
+ return all(
+ _is_finite_number(a)
+ and _is_finite_number(b)
+ and math.isclose(float(a), float(b), abs_tol=tolerance, rel_tol=tolerance)
+ for a, b in zip(left, right)
+ )
+
+
+def _scan_for_non_finite(data: Any, path: str = "") -> List[str]:
+ """Recursively scans a data structure for any NaN/Inf values."""
+ non_finites: List[str] = []
+ if isinstance(data, float):
+ if not math.isfinite(data):
+ non_finites.append(f"{path}: {data}")
+ elif isinstance(data, dict):
+ for k, v in data.items():
+ non_finites.extend(_scan_for_non_finite(v, f"{path}.{k}" if path else str(k)))
+ elif isinstance(data, (list, tuple)):
+ for idx, item in enumerate(data):
+ non_finites.extend(_scan_for_non_finite(item, f"{path}[{idx}]"))
+ return non_finites
+
+
+def evaluate_artifact(artifact: Dict[str, Any]) -> Dict[str, Any]:
+ """Strictly evaluates a post-training PSO ensemble experiment artifact.
+
+ Args:
+ artifact: Parsed JSON experiment artifact dictionary.
+
+ Returns:
+ Structured evaluation payload with score, pass/fail status, gate counts,
+ and categorized issues. Never relies on self-reported artifact pass flags.
+ """
+ issues: Dict[str, List[str]] = {
+ "schema": [],
+ "config": [],
+ "finite": [],
+ "weights": [],
+ "accounting": [],
+ "leakage": [],
+ "tuning": [],
+ "slsqp": [],
+ "consistency": [],
+ "gates": [],
+ }
+
+ if not isinstance(artifact, dict):
+ _append_issue(issues, "schema", "Artifact must be a JSON object")
+ return {
+ "evaluator_version": EVALUATOR_VERSION,
+ "pass": False,
+ "score": -1000.0,
+ "development_pass": False,
+ "confirmation_pass": False,
+ "failed_hard_gate_count": 1,
+ "issues": issues,
+ "development_gates": {},
+ "confirmation_gates": None,
+ "metrics": {},
+ }
+
+ # 1. Non-finite value scan
+ non_finite_locations = _scan_for_non_finite(artifact)
+ if non_finite_locations:
+ for loc in non_finite_locations[:10]:
+ _append_issue(issues, "finite", f"Non-finite value found at {loc}")
+
+ # Protocol version check
+ protocol_version = artifact.get("protocol_version")
+ if protocol_version != EXPECTED_PROTOCOL_VERSION:
+ _append_issue(
+ issues,
+ "config",
+ f"Artifact protocol_version must be '{EXPECTED_PROTOCOL_VERSION}', got '{protocol_version}'",
+ )
+
+ # 2. Config & Protocol verification
+ config = artifact.get("config")
+ if not isinstance(config, dict):
+ _append_issue(issues, "schema", "Missing or non-object top-level 'config'")
+ config = {}
+
+ datasets = config.get("datasets")
+ if not isinstance(datasets, list) or sorted(datasets) != sorted(EXPECTED_DATASETS):
+ _append_issue(issues, "config", f"Config 'datasets' must be {EXPECTED_DATASETS}")
+
+ if config.get("split_seed") != EXPECTED_SPLIT_SEED:
+ _append_issue(issues, "config", f"Config 'split_seed' must be {EXPECTED_SPLIT_SEED}")
+
+ if config.get("search_samples") != EXPECTED_SEARCH_SAMPLES:
+ _append_issue(
+ issues, "config", f"Config 'search_samples' must be {EXPECTED_SEARCH_SAMPLES}"
+ )
+
+ if config.get("validation_samples") != EXPECTED_VAL_SAMPLES:
+ _append_issue(
+ issues, "config", f"Config 'validation_samples' must be {EXPECTED_VAL_SAMPLES}"
+ )
+
+ if config.get("pool_seeds") != EXPECTED_POOL_SEEDS:
+ _append_issue(issues, "config", f"Config 'pool_seeds' must be {EXPECTED_POOL_SEEDS}")
+
+ if config.get("reference_single_seed") != EXPECTED_REF_SINGLE_SEED:
+ _append_issue(
+ issues, "config", f"Config 'reference_single_seed' must be {EXPECTED_REF_SINGLE_SEED}"
+ )
+
+ if config.get("equal_budget_single_epochs") != EXPECTED_50E_SINGLE_EPOCHS:
+ _append_issue(
+ issues,
+ "config",
+ f"Config 'equal_budget_single_epochs' must be {EXPECTED_50E_SINGLE_EPOCHS}",
+ )
+
+ pso_cfg = config.get("pso", {}) if isinstance(config.get("pso"), dict) else {}
+ if pso_cfg.get("particles") != EXPECTED_PARTICLES:
+ _append_issue(
+ issues, "config", f"Config 'pso.particles' must be {EXPECTED_PARTICLES}"
+ )
+ if pso_cfg.get("epochs") != EXPECTED_EPOCHS:
+ _append_issue(issues, "config", f"Config 'pso.epochs' must be {EXPECTED_EPOCHS}")
+ if pso_cfg.get("swarm_seeds") != EXPECTED_SWARM_SEEDS:
+ _append_issue(
+ issues, "config", f"Config 'pso.swarm_seeds' must be {EXPECTED_SWARM_SEEDS}"
+ )
+ if pso_cfg.get("queries_per_seed") != EXPECTED_QUERIES_PER_SEED:
+ _append_issue(
+ issues,
+ "accounting",
+ f"Config 'pso.queries_per_seed' must be {EXPECTED_QUERIES_PER_SEED}",
+ )
+ if pso_cfg.get("sample_evaluations_per_seed") != EXPECTED_SAMPLES_PER_SEED:
+ _append_issue(
+ issues,
+ "accounting",
+ f"Config 'pso.sample_evaluations_per_seed' must be {EXPECTED_SAMPLES_PER_SEED}",
+ )
+
+ # Validate frozen PSO hyperparameters in config
+ if pso_cfg.get("method") != "constriction":
+ _append_issue(issues, "config", f"Config 'pso.method' must be 'constriction', got '{pso_cfg.get('method')}'")
+ if pso_cfg.get("evaluation") != "full":
+ _append_issue(issues, "config", f"Config 'pso.evaluation' must be 'full', got '{pso_cfg.get('evaluation')}'")
+ if pso_cfg.get("renewal") != "loss":
+ _append_issue(issues, "config", f"Config 'pso.renewal' must be 'loss', got '{pso_cfg.get('renewal')}'")
+ if pso_cfg.get("particle_bounds") != [-4.0, 4.0]:
+ _append_issue(issues, "config", f"Config 'pso.particle_bounds' must be [-4.0, 4.0], got '{pso_cfg.get('particle_bounds')}'")
+ if pso_cfg.get("boundary_strategy") != "reflect":
+ _append_issue(issues, "config", f"Config 'pso.boundary_strategy' must be 'reflect', got '{pso_cfg.get('boundary_strategy')}'")
+ if pso_cfg.get("velocity_limit_ratio") != 0.1:
+ _append_issue(issues, "config", f"Config 'pso.velocity_limit_ratio' must be 0.1, got '{pso_cfg.get('velocity_limit_ratio')}'")
+ if pso_cfg.get("initial_position_noise") != 0.0:
+ _append_issue(issues, "config", f"Config 'pso.initial_position_noise' must be 0.0, got '{pso_cfg.get('initial_position_noise')}'")
+
+ # 3. Leakage and Post-Test Tuning checks
+ post_test_tuning = artifact.get("post_test_tuning_or_reruns", 0)
+ if post_test_tuning != 0:
+ _append_issue(
+ issues,
+ "tuning",
+ f"post_test_tuning_or_reruns must be 0, got {post_test_tuning}",
+ )
+
+ if "official_test_data_loaded_before_freeze" in artifact:
+ global_pre_loaded = artifact["official_test_data_loaded_before_freeze"]
+ if global_pre_loaded is not False:
+ _append_issue(
+ issues,
+ "leakage",
+ "Top-level official_test_data_loaded_before_freeze must be False "
+ f"when present, got {global_pre_loaded}",
+ )
+ if "official_test_evaluations_before_freeze" in artifact:
+ global_pre_evals = artifact["official_test_evaluations_before_freeze"]
+ if global_pre_evals != 0:
+ _append_issue(
+ issues,
+ "leakage",
+ "Top-level official_test_evaluations_before_freeze must be 0 "
+ f"when present, got {global_pre_evals}",
+ )
+
+ # 4. Workloads & Validation Analysis
+ workloads = artifact.get("workloads")
+ if not isinstance(workloads, dict):
+ _append_issue(issues, "schema", "Missing or non-object top-level 'workloads'")
+ workloads = {}
+
+ pre_freeze_loaded_ok = (
+ artifact.get("official_test_data_loaded_before_freeze", False) is False
+ )
+ pre_freeze_evals_ok = (
+ artifact.get("official_test_evaluations_before_freeze", 0) == 0
+ )
+
+ val_metrics_by_dataset: Dict[str, Dict[str, Dict[str, float]]] = {}
+ test_metrics_by_dataset: Dict[str, Dict[str, Dict[str, float]]] = {}
+ val_cache_counts: Dict[str, Dict[str, int]] = {}
+
+ pso_wall_times: Dict[str, List[float]] = {}
+ adam_pool_wall_times: Dict[str, float] = {}
+
+ for ds in EXPECTED_DATASETS:
+ if ds not in workloads:
+ _append_issue(issues, "schema", f"Workloads missing dataset '{ds}'")
+ pre_freeze_loaded_ok = False
+ pre_freeze_evals_ok = False
+ continue
+ wl = workloads[ds]
+ if not isinstance(wl, dict):
+ _append_issue(issues, "schema", f"Workload '{ds}' must be a JSON object")
+ pre_freeze_loaded_ok = False
+ pre_freeze_evals_ok = False
+ continue
+
+ # Per-workload declarations are mandatory and cannot mask contradictory
+ # top-level leakage counters.
+ wl_pre_loaded = wl.get("official_test_data_loaded_before_freeze")
+ if wl_pre_loaded is not False:
+ pre_freeze_loaded_ok = False
+ _append_issue(
+ issues,
+ "leakage",
+ f"Dataset '{ds}' official_test_data_loaded_before_freeze must be False, got {wl_pre_loaded}",
+ )
+
+ wl_pre_evals = wl.get("official_test_evaluations_before_freeze")
+ if wl_pre_evals != 0:
+ pre_freeze_evals_ok = False
+ _append_issue(
+ issues,
+ "leakage",
+ f"Dataset '{ds}' official_test_evaluations_before_freeze must be 0, got {wl_pre_evals}",
+ )
+
+ # Validation cache key checks:
+ # pool_forward_passes (5), long_single_forward_passes (1), base_cnn_forward_passes_during_optimization (0)
+ val_cache = wl.get("validation_cache") if isinstance(wl.get("validation_cache"), dict) else wl
+ val_pool_passes = val_cache.get("pool_forward_passes", val_cache.get("validation_pool_forward_passes"))
+ long_single_passes = val_cache.get("long_single_forward_passes", val_cache.get("val_long_single_passes", 1))
+ opt_base_passes = val_cache.get("base_cnn_forward_passes_during_optimization", val_cache.get("optimization_base_model_forward_passes"))
+
+ val_cache_counts[ds] = {
+ "pool_forward_passes": int(val_pool_passes) if _is_finite_number(val_pool_passes) else -1,
+ "long_single_forward_passes": int(long_single_passes) if _is_finite_number(long_single_passes) else -1,
+ "base_cnn_forward_passes_during_optimization": int(opt_base_passes) if _is_finite_number(opt_base_passes) else -1,
+ }
+
+ if val_cache_counts[ds]["pool_forward_passes"] != 5:
+ _append_issue(
+ issues,
+ "accounting",
+ f"Dataset '{ds}' validation pool_forward_passes must be 5, got {val_pool_passes}",
+ )
+ if val_cache_counts[ds]["base_cnn_forward_passes_during_optimization"] != 0:
+ _append_issue(
+ issues,
+ "accounting",
+ f"Dataset '{ds}' base_cnn_forward_passes_during_optimization must be 0, got {opt_base_passes}",
+ )
+
+ # Extract Adam pool training wall time (key: adam_pool_wall_time_seconds)
+ training_info = wl.get("training") if isinstance(wl.get("training"), dict) else wl
+ adam_wall = training_info.get("adam_pool_wall_time_seconds", training_info.get("adam_pool_wall_time"))
+ if _is_finite_number(adam_wall):
+ adam_pool_wall_times[ds] = float(adam_wall)
+
+ # Validate validation methods dict & exact method set
+ val_sec = wl.get("validation") if isinstance(wl.get("validation"), dict) else wl
+ methods_dict = val_sec.get("methods") if isinstance(val_sec.get("methods"), dict) else val_sec
+
+ if not isinstance(methods_dict, dict):
+ _append_issue(issues, "schema", f"Dataset '{ds}' validation methods must be a dictionary")
+ methods_dict = {}
+
+ present_methods = set(methods_dict.keys())
+ if present_methods != REQUIRED_BASELINES_SET:
+ _append_issue(
+ issues,
+ "schema",
+ f"Dataset '{ds}' validation methods set {present_methods} does not match required {REQUIRED_BASELINES_SET}",
+ )
+
+ ds_val_metrics: Dict[str, Dict[str, float]] = {}
+ for method in REQUIRED_BASELINES:
+ if method not in methods_dict:
+ _append_issue(issues, "schema", f"Dataset '{ds}' validation missing method '{method}'")
+ continue
+
+ entry = methods_dict[method]
+ acc, nll = _unwrap_metrics(entry)
+
+ if acc is None or nll is None:
+ _append_issue(
+ issues,
+ "finite",
+ f"Dataset '{ds}' validation method '{method}' has missing or non-finite acc/nll",
+ )
+ else:
+ ds_val_metrics[method] = {"acc": acc, "nll": nll}
+
+ # Simplex weight checks for weighted methods (slsqp_weights, pso_weights)
+ if method in WEIGHTED_METHODS:
+ weights = entry.get("weights", entry.get("selected_weights")) if isinstance(entry, dict) else None
+ if not _validate_simplex_weights(weights):
+ _append_issue(
+ issues,
+ "weights",
+ f"Dataset '{ds}' validation method '{method}' has invalid simplex weights: {weights}",
+ )
+
+ # SLSQP solver success check
+ if method == "slsqp_weights":
+ solver_success = entry.get("success", entry.get("status") in (0, "success", True)) if isinstance(entry, dict) else False
+ if solver_success is False:
+ _append_issue(
+ issues,
+ "slsqp",
+ f"Dataset '{ds}' SLSQP solver failed (success=False)",
+ )
+
+ # PSO detailed run & seed verification
+ if method == "pso_weights":
+ seed_runs = entry.get("per_seed_runs") if isinstance(entry, dict) else None
+ if not isinstance(seed_runs, list) or len(seed_runs) != len(EXPECTED_SWARM_SEEDS):
+ _append_issue(
+ issues,
+ "schema",
+ f"Dataset '{ds}' PSO pso_weights per_seed_runs must contain {len(EXPECTED_SWARM_SEEDS)} seed runs",
+ )
+ else:
+ recorded_seeds: List[int] = []
+ run_times: List[float] = []
+ best_run_nll = float("inf")
+ best_run_entry: Optional[Dict[str, Any]] = None
+
+ for idx, run in enumerate(seed_runs):
+ if not isinstance(run, dict):
+ _append_issue(
+ issues, "schema", f"Dataset '{ds}' PSO seed run {idx} is non-dict"
+ )
+ continue
+
+ seed = run.get("seed")
+ if seed not in EXPECTED_SWARM_SEEDS:
+ _append_issue(
+ issues, "config", f"Dataset '{ds}' PSO seed run seed {seed} unexpected"
+ )
+ if isinstance(seed, int) and not isinstance(seed, bool):
+ recorded_seeds.append(seed)
+
+ queries = run.get("queries", run.get("total_queries"))
+ # PSO per-seed sample key: sample_evaluations, samples, or total_sample_evaluations
+ samples = run.get("sample_evaluations", run.get("samples", run.get("total_sample_evaluations")))
+ if queries != EXPECTED_QUERIES_PER_SEED:
+ _append_issue(
+ issues,
+ "accounting",
+ f"Dataset '{ds}' PSO seed {seed} queries must be {EXPECTED_QUERIES_PER_SEED}, got {queries}",
+ )
+ if samples != EXPECTED_SAMPLES_PER_SEED:
+ _append_issue(
+ issues,
+ "accounting",
+ f"Dataset '{ds}' PSO seed {seed} samples must be {EXPECTED_SAMPLES_PER_SEED}, got {samples}",
+ )
+
+ r_weights = run.get("weights")
+ if not _validate_simplex_weights(r_weights):
+ _append_issue(
+ issues,
+ "weights",
+ f"Dataset '{ds}' PSO seed {seed} weights invalid: {r_weights}",
+ )
+
+ w_time = run.get("wall_time_seconds", run.get("wall_time", run.get("time")))
+ if _is_finite_number(w_time):
+ run_times.append(float(w_time))
+ else:
+ _append_issue(
+ issues,
+ "finite",
+ f"Dataset '{ds}' PSO seed {seed} missing or non-finite wall_time_seconds",
+ )
+
+ r_acc, r_nll = _unwrap_metrics(run)
+ if r_nll is not None and r_nll < best_run_nll:
+ best_run_nll = r_nll
+ best_run_entry = run
+
+ if sorted(recorded_seeds) != EXPECTED_SWARM_SEEDS:
+ _append_issue(
+ issues,
+ "config",
+ f"Dataset '{ds}' PSO seed runs must contain each frozen seed exactly once; "
+ f"got {recorded_seeds}",
+ )
+
+ if run_times:
+ pso_wall_times[ds] = run_times
+
+ # Validate selected PSO top metrics/weights/seed equal best per-seed NLL record
+ if isinstance(entry, dict):
+ top_selected_seed = entry.get("selected_seed")
+ top_weights = entry.get("selected_weights", entry.get("weights"))
+ top_acc, top_nll = _unwrap_metrics(entry)
+
+ if best_run_entry is not None:
+ best_seed = best_run_entry.get("seed")
+ best_weights = best_run_entry.get("weights")
+ best_acc, _ = _unwrap_metrics(best_run_entry)
+
+ if top_selected_seed != best_seed:
+ _append_issue(
+ issues,
+ "consistency",
+ f"Dataset '{ds}' pso_weights selected_seed ({top_selected_seed}) != best seed ({best_seed})",
+ )
+ if top_weights != best_weights and not (
+ isinstance(top_weights, list)
+ and isinstance(best_weights, list)
+ and len(top_weights) == len(best_weights)
+ and all(math.isclose(a, b, abs_tol=1e-6) for a, b in zip(top_weights, best_weights))
+ ):
+ _append_issue(
+ issues,
+ "consistency",
+ f"Dataset '{ds}' pso_weights weights disagree with best seed run weights",
+ )
+ if top_nll is not None and not math.isclose(top_nll, best_run_nll, abs_tol=1e-6, rel_tol=1e-5):
+ _append_issue(
+ issues,
+ "consistency",
+ f"Dataset '{ds}' pso_weights top NLL ({top_nll}) != best seed run NLL ({best_run_nll})",
+ )
+ if top_acc is not None and best_acc is not None and not math.isclose(top_acc, best_acc, abs_tol=1e-6, rel_tol=1e-5):
+ _append_issue(
+ issues,
+ "consistency",
+ f"Dataset '{ds}' pso_weights top acc ({top_acc}) != best seed run acc ({best_acc})",
+ )
+
+ val_metrics_by_dataset[ds] = ds_val_metrics
+
+ # 5. Development Hard Gates Recomputation
+ # Named booleans assess their own fields directly
+ dev_gates: Dict[str, bool] = {
+ "all_values_finite": len(issues["finite"]) == 0,
+ "simplex_tolerance": len(issues["weights"]) == 0,
+ "validation_pool_forward_passes_each_dataset": all(
+ val_cache_counts.get(ds, {}).get("pool_forward_passes") == 5
+ for ds in EXPECTED_DATASETS
+ ),
+ "optimization_base_model_forward_passes": all(
+ val_cache_counts.get(ds, {}).get("base_cnn_forward_passes_during_optimization") == 0
+ for ds in EXPECTED_DATASETS
+ ),
+ "official_test_data_loaded_before_freeze": pre_freeze_loaded_ok,
+ "official_test_evaluations_before_freeze": pre_freeze_evals_ok,
+ "query_and_sample_accounting_exact": len(issues["accounting"]) == 0,
+ "maximum_pso_nll_regression_vs_uniform": True,
+ "maximum_pso_accuracy_regression_vs_uniform_pp": True,
+ "pso_nll_below_reference_single": True,
+ "maximum_pso_nll_regression_vs_equal_budget_single": True,
+ "maximum_relative_pso_nll_gap_vs_slsqp": True,
+ "cross_dataset_mean_relative_pso_nll_reduction_vs_uniform_minimum": True,
+ "maximum_median_one_seed_pso_to_pool_training_wall_ratio": True,
+ }
+
+ # Evaluate metric-dependent development gates across datasets
+ rel_nll_reductions_vs_uniform: List[float] = []
+ pso_wall_ratios: Dict[str, float] = {}
+
+ for ds in EXPECTED_DATASETS:
+ m = val_metrics_by_dataset.get(ds, {})
+ pso_nll = m.get("pso_weights", {}).get("nll")
+ pso_acc = m.get("pso_weights", {}).get("acc")
+ unif_nll = m.get("uniform_ensemble", {}).get("nll")
+ unif_acc = m.get("uniform_ensemble", {}).get("acc")
+ ref_nll = m.get("reference_single_10e", {}).get("nll")
+ s50_nll = m.get("single_50e", {}).get("nll")
+ slsqp_nll = m.get("slsqp_weights", {}).get("nll")
+
+ # Nominal gate booleans cannot stay True if required inputs are missing!
+ if any(v is None for v in (pso_nll, unif_nll, ref_nll, s50_nll, slsqp_nll, pso_acc, unif_acc)):
+ dev_gates["maximum_pso_nll_regression_vs_uniform"] = False
+ dev_gates["maximum_pso_accuracy_regression_vs_uniform_pp"] = False
+ dev_gates["pso_nll_below_reference_single"] = False
+ dev_gates["maximum_pso_nll_regression_vs_equal_budget_single"] = False
+ dev_gates["maximum_relative_pso_nll_gap_vs_slsqp"] = False
+ dev_gates["cross_dataset_mean_relative_pso_nll_reduction_vs_uniform_minimum"] = False
+
+ # Gate 8: maximum PSO NLL regression vs uniform <= 1e-7
+ if pso_nll is not None and unif_nll is not None:
+ if (pso_nll - unif_nll) > 1e-7:
+ dev_gates["maximum_pso_nll_regression_vs_uniform"] = False
+ _append_issue(
+ issues,
+ "gates",
+ f"Dataset '{ds}' val PSO NLL ({pso_nll:.6f}) > uniform NLL ({unif_nll:.6f}) by > 1e-7",
+ )
+ rel_nll_reductions_vs_uniform.append((unif_nll - pso_nll) / unif_nll)
+
+ # Gate 9: maximum PSO accuracy regression vs uniform <= 0.10 pp
+ if pso_acc is not None and unif_acc is not None:
+ acc_diff_pp = _to_pp(unif_acc) - _to_pp(pso_acc)
+ if acc_diff_pp > 0.10:
+ dev_gates["maximum_pso_accuracy_regression_vs_uniform_pp"] = False
+ _append_issue(
+ issues,
+ "gates",
+ f"Dataset '{ds}' val PSO acc regression vs uniform ({acc_diff_pp:.4f} pp) > 0.10 pp",
+ )
+
+ # Gate 10: PSO NLL strictly below reference single
+ if pso_nll is not None and ref_nll is not None:
+ if pso_nll >= ref_nll:
+ dev_gates["pso_nll_below_reference_single"] = False
+ _append_issue(
+ issues,
+ "gates",
+ f"Dataset '{ds}' val PSO NLL ({pso_nll:.6f}) >= reference single NLL ({ref_nll:.6f})",
+ )
+
+ # Gate 11: maximum PSO NLL regression vs equal-budget 50e single <= 1e-7
+ if pso_nll is not None and s50_nll is not None:
+ if (pso_nll - s50_nll) > 1e-7:
+ dev_gates["maximum_pso_nll_regression_vs_equal_budget_single"] = False
+ _append_issue(
+ issues,
+ "gates",
+ f"Dataset '{ds}' val PSO NLL ({pso_nll:.6f}) > 50e single NLL ({s50_nll:.6f}) by > 1e-7",
+ )
+
+ # Gate 12: maximum relative PSO NLL gap vs SLSQP <= 0.005
+ if pso_nll is not None and slsqp_nll is not None and slsqp_nll > 0:
+ rel_gap = (pso_nll - slsqp_nll) / slsqp_nll
+ if rel_gap > 0.005:
+ dev_gates["maximum_relative_pso_nll_gap_vs_slsqp"] = False
+ _append_issue(
+ issues,
+ "gates",
+ f"Dataset '{ds}' val PSO NLL gap vs SLSQP ({rel_gap:.4%}) > 0.5%",
+ )
+
+ # Gate 14 wall time ratio accounting
+ if ds in pso_wall_times and ds in adam_pool_wall_times and adam_pool_wall_times[ds] > 0:
+ sorted_times = sorted(pso_wall_times[ds])
+ median_pso = sorted_times[len(sorted_times) // 2]
+ pso_wall_ratios[ds] = median_pso / adam_pool_wall_times[ds]
+
+ # Gate 13: cross-dataset mean relative PSO NLL reduction vs uniform >= 0.0
+ if rel_nll_reductions_vs_uniform:
+ mean_reduction = math.fsum(rel_nll_reductions_vs_uniform) / len(rel_nll_reductions_vs_uniform)
+ if mean_reduction < 0.0:
+ dev_gates["cross_dataset_mean_relative_pso_nll_reduction_vs_uniform_minimum"] = False
+ _append_issue(
+ issues,
+ "gates",
+ f"Mean relative val PSO NLL reduction vs uniform ({mean_reduction:.4%}) < 0.0",
+ )
+ else:
+ dev_gates["cross_dataset_mean_relative_pso_nll_reduction_vs_uniform_minimum"] = False
+
+ # Gate 14: every workload must satisfy the frozen 10% wall-time ceiling.
+ res_totals = (
+ artifact.get("resource_totals")
+ if isinstance(artifact.get("resource_totals"), dict)
+ else {}
+ )
+ if set(pso_wall_ratios) != set(EXPECTED_DATASETS):
+ dev_gates["maximum_median_one_seed_pso_to_pool_training_wall_ratio"] = False
+ _append_issue(
+ issues,
+ "accounting",
+ "Cannot recompute a finite positive PSO/Adam wall ratio for every dataset",
+ )
+ else:
+ for ds, ratio in pso_wall_ratios.items():
+ if not math.isfinite(ratio) or ratio > 0.10:
+ dev_gates["maximum_median_one_seed_pso_to_pool_training_wall_ratio"] = False
+ _append_issue(
+ issues,
+ "gates",
+ f"Dataset '{ds}' median PSO wall time to Adam pool wall ratio "
+ f"({ratio:.2%}) > 10%",
+ )
+
+ sorted_ratios = sorted(pso_wall_ratios.values())
+ mid = len(sorted_ratios) // 2
+ recomputed_ratio = (
+ sorted_ratios[mid]
+ if len(sorted_ratios) % 2
+ else 0.5 * (sorted_ratios[mid - 1] + sorted_ratios[mid])
+ )
+ reported_ratio = res_totals.get("pso_to_pool_wall_ratio")
+ if not _is_finite_number(reported_ratio) or not math.isclose(
+ float(reported_ratio),
+ recomputed_ratio,
+ abs_tol=1e-12,
+ rel_tol=1e-9,
+ ):
+ dev_gates["maximum_median_one_seed_pso_to_pool_training_wall_ratio"] = False
+ _append_issue(
+ issues,
+ "accounting",
+ "resource_totals.pso_to_pool_wall_ratio does not match the "
+ f"per-dataset recomputation ({recomputed_ratio:.12f}); got {reported_ratio}",
+ )
+
+ # Check structural/config/accounting/leakage/SLSQP/weights/finite/tuning errors
+ dev_has_structural_errors = (
+ len(issues["schema"]) > 0
+ or len(issues["config"]) > 0
+ or len(issues["finite"]) > 0
+ or len(issues["weights"]) > 0
+ or len(issues["accounting"]) > 0
+ or len(issues["leakage"]) > 0
+ or len(issues["tuning"]) > 0
+ or len(issues["slsqp"]) > 0
+ or len(issues["consistency"]) > 0
+ )
+
+ development_pass = all(dev_gates.values()) and not dev_has_structural_errors
+
+ # 6. Confirmation Phase Verification
+ official_test_data_loaded = artifact.get("official_test_data_loaded")
+ confirmation_pass = False
+ conf_gates: Optional[Dict[str, bool]] = None
+
+ if not development_pass:
+ if official_test_data_loaded is not False and official_test_data_loaded is True:
+ _append_issue(
+ issues,
+ "leakage",
+ "official_test_data_loaded must be False when development fails",
+ )
+
+ conf_improper = False
+ for ds in EXPECTED_DATASETS:
+ wl = workloads.get(ds) if isinstance(workloads.get(ds), dict) else {}
+ conf_wl = wl.get("confirmation")
+ if conf_wl is not None and conf_wl != {}:
+ conf_improper = True
+ _append_issue(
+ issues,
+ "gates",
+ f"Dataset '{ds}' confirmation present despite development failure",
+ )
+
+ if conf_improper or (official_test_data_loaded is not False and official_test_data_loaded is True):
+ conf_gates = {"confirmation_absent_when_dev_failed": False}
+ else:
+ conf_gates = None
+ else: # development_pass is True
+ if official_test_data_loaded is not True:
+ _append_issue(
+ issues,
+ "leakage",
+ "official_test_data_loaded must be True when development passed",
+ )
+
+ conf_missing = False
+ for ds in EXPECTED_DATASETS:
+ wl = workloads.get(ds) if isinstance(workloads.get(ds), dict) else {}
+ conf_wl = wl.get("confirmation")
+ if conf_wl is None or not isinstance(conf_wl, dict) or conf_wl == {}:
+ conf_missing = True
+ _append_issue(
+ issues,
+ "gates",
+ f"Dataset '{ds}' confirmation missing when development passed",
+ )
+
+ if conf_missing or official_test_data_loaded is not True:
+ conf_gates = {"confirmation_present_and_loaded": False}
+ else:
+ conf_gates = {
+ "all_values_finite": True,
+ "official_test_dataset_loads_each_dataset": True,
+ "official_test_pool_forward_passes_each_dataset": True,
+ "official_test_long_single_forward_passes_each_dataset": True,
+ "frozen_policy_consistency": artifact.get("policy_frozen") is True,
+ "maximum_pso_accuracy_regression_vs_uniform_pp": True,
+ "pso_nll_below_reference_single": True,
+ "maximum_pso_nll_regression_vs_equal_budget_single": True,
+ "post_test_tuning_or_reruns": artifact.get("post_test_tuning_or_reruns", 0) == 0,
+ }
+ if not conf_gates["frozen_policy_consistency"]:
+ _append_issue(
+ issues,
+ "leakage",
+ "policy_frozen must be True before official confirmation",
+ )
+
+ for ds in EXPECTED_DATASETS:
+ wl = workloads.get(ds, {})
+ conf_wl = wl.get("confirmation", {})
+ val_methods = wl.get("validation", {}).get("methods", {})
+ frozen_methods = conf_wl.get("frozen_methods")
+ expected_pso = val_methods.get("pso_weights", {})
+ expected_slsqp = val_methods.get("slsqp_weights", {})
+ expected_temp = val_methods.get("uniform_temperature", {})
+ frozen_ok = (
+ isinstance(frozen_methods, dict)
+ and frozen_methods.get("selected_pso_seed")
+ == expected_pso.get("selected_seed")
+ and _sequences_close(
+ frozen_methods.get("selected_pso_weights"),
+ expected_pso.get("selected_weights"),
+ )
+ and _sequences_close(
+ frozen_methods.get("slsqp_weights"),
+ expected_slsqp.get("weights"),
+ )
+ and _is_finite_number(frozen_methods.get("fitted_temperature"))
+ and _is_finite_number(expected_temp.get("fitted_temperature"))
+ and math.isclose(
+ float(frozen_methods["fitted_temperature"]),
+ float(expected_temp["fitted_temperature"]),
+ abs_tol=1e-6,
+ rel_tol=1e-6,
+ )
+ )
+ if not frozen_ok:
+ conf_gates["frozen_policy_consistency"] = False
+ _append_issue(
+ issues,
+ "consistency",
+ f"Dataset '{ds}' confirmation frozen_methods do not match "
+ "the validation-frozen PSO seed/weights, SLSQP weights, and temperature",
+ )
+
+ # Per-workload confirmation cache is test_cache_counts with dataset_loads, pool_forward_passes, long_single_forward_passes
+ c_cache = conf_wl.get("test_cache_counts") if isinstance(conf_wl.get("test_cache_counts"), dict) else conf_wl.get("cache", conf_wl)
+ t_loads = c_cache.get("dataset_loads", c_cache.get("official_test_dataset_loads"))
+ t_pool_passes = c_cache.get("pool_forward_passes", c_cache.get("official_test_pool_forward_passes"))
+ t_single_passes = c_cache.get("long_single_forward_passes", c_cache.get("official_test_long_single_forward_passes"))
+
+ if t_loads != 1:
+ conf_gates["official_test_dataset_loads_each_dataset"] = False
+ _append_issue(issues, "accounting", f"Dataset '{ds}' test dataset_loads must be 1, got {t_loads}")
+ if t_pool_passes != 5:
+ conf_gates["official_test_pool_forward_passes_each_dataset"] = False
+ _append_issue(issues, "accounting", f"Dataset '{ds}' test pool_forward_passes must be 5, got {t_pool_passes}")
+ if t_single_passes != 1:
+ conf_gates["official_test_long_single_forward_passes_each_dataset"] = False
+ _append_issue(issues, "accounting", f"Dataset '{ds}' test long_single_forward_passes must be 1, got {t_single_passes}")
+
+ # Test methods dict verification
+ methods_dict = conf_wl.get("methods") if isinstance(conf_wl.get("methods"), dict) else conf_wl
+ if not isinstance(methods_dict, dict):
+ conf_gates["all_values_finite"] = False
+ _append_issue(issues, "schema", f"Dataset '{ds}' confirmation methods must be a dictionary")
+ methods_dict = {}
+
+ present_methods = set(methods_dict.keys())
+ if present_methods != REQUIRED_BASELINES_SET:
+ conf_gates["all_values_finite"] = False
+ _append_issue(
+ issues,
+ "schema",
+ f"Dataset '{ds}' confirmation methods set {present_methods} does not match required {REQUIRED_BASELINES_SET}",
+ )
+
+ ds_test_metrics: Dict[str, Dict[str, float]] = {}
+ for method in REQUIRED_BASELINES:
+ if method not in methods_dict:
+ conf_gates["all_values_finite"] = False
+ _append_issue(issues, "schema", f"Dataset '{ds}' confirmation missing method '{method}'")
+ continue
+
+ entry = methods_dict[method]
+ acc, nll = _unwrap_metrics(entry)
+
+ if acc is None or nll is None:
+ conf_gates["all_values_finite"] = False
+ _append_issue(
+ issues,
+ "finite",
+ f"Dataset '{ds}' confirmation method '{method}' has missing or non-finite acc/nll",
+ )
+ else:
+ ds_test_metrics[method] = {"acc": acc, "nll": nll}
+
+ test_metrics_by_dataset[ds] = ds_test_metrics
+
+ pso_test_nll = ds_test_metrics.get("pso_weights", {}).get("nll")
+ pso_test_acc = ds_test_metrics.get("pso_weights", {}).get("acc")
+ unif_test_acc = ds_test_metrics.get("uniform_ensemble", {}).get("acc")
+ ref_test_nll = ds_test_metrics.get("reference_single_10e", {}).get("nll")
+ s50_test_nll = ds_test_metrics.get("single_50e", {}).get("nll")
+
+ if any(v is None for v in (pso_test_nll, pso_test_acc, unif_test_acc, ref_test_nll, s50_test_nll)):
+ conf_gates["all_values_finite"] = False
+ conf_gates["maximum_pso_accuracy_regression_vs_uniform_pp"] = False
+ conf_gates["pso_nll_below_reference_single"] = False
+ conf_gates["maximum_pso_nll_regression_vs_equal_budget_single"] = False
+
+ if pso_test_acc is not None and unif_test_acc is not None:
+ diff_pp = _to_pp(unif_test_acc) - _to_pp(pso_test_acc)
+ if diff_pp > 0.20:
+ conf_gates["maximum_pso_accuracy_regression_vs_uniform_pp"] = False
+ _append_issue(
+ issues,
+ "gates",
+ f"Dataset '{ds}' test PSO acc regression vs uniform ({diff_pp:.4f} pp) > 0.20 pp",
+ )
+
+ if pso_test_nll is not None and ref_test_nll is not None:
+ if pso_test_nll >= ref_test_nll:
+ conf_gates["pso_nll_below_reference_single"] = False
+ _append_issue(
+ issues,
+ "gates",
+ f"Dataset '{ds}' test PSO NLL ({pso_test_nll:.6f}) >= reference single NLL ({ref_test_nll:.6f})",
+ )
+
+ if pso_test_nll is not None and s50_test_nll is not None:
+ if (pso_test_nll - s50_test_nll) > 1e-7:
+ conf_gates["maximum_pso_nll_regression_vs_equal_budget_single"] = False
+ _append_issue(
+ issues,
+ "gates",
+ f"Dataset '{ds}' test PSO NLL ({pso_test_nll:.6f}) > 50e single NLL ({s50_test_nll:.6f}) by > 1e-7",
+ )
+
+ confirmation_pass = all(conf_gates.values())
+
+ # 7. Failed Gate Counting & Numeric Score Calculation
+ # Count structural/config/accounting/leakage/SLSQP/weights/finite/tuning errors as hard failures
+ structural_issue_count = sum(len(lst) for lst in issues.values())
+ failed_dev_gates = sum(1 for v in dev_gates.values() if not v)
+ failed_conf_gates = (
+ sum(1 for v in conf_gates.values() if not v) if conf_gates is not None else (1 if development_pass else 0)
+ )
+ failed_hard_gate_count = max(failed_dev_gates + failed_conf_gates, structural_issue_count)
+
+ # Calculate validation score metrics
+ val_rel_nll_reductions: List[float] = []
+ val_acc_gains_pp: List[float] = []
+ test_rel_nll_reductions: List[float] = []
+ test_acc_gains_pp: List[float] = []
+
+ for ds in EXPECTED_DATASETS:
+ m_val = val_metrics_by_dataset.get(ds, {})
+ pso_v_nll = m_val.get("pso_weights", {}).get("nll")
+ pso_v_acc = m_val.get("pso_weights", {}).get("acc")
+ s50_v_nll = m_val.get("single_50e", {}).get("nll")
+ s50_v_acc = m_val.get("single_50e", {}).get("acc")
+
+ if pso_v_nll is not None and s50_v_nll is not None and s50_v_nll > 0:
+ val_rel_nll_reductions.append((s50_v_nll - pso_v_nll) / s50_v_nll)
+ if pso_v_acc is not None and s50_v_acc is not None:
+ val_acc_gains_pp.append(_to_pp(pso_v_acc) - _to_pp(s50_v_acc))
+
+ m_test = test_metrics_by_dataset.get(ds, {})
+ pso_t_nll = m_test.get("pso_weights", {}).get("nll")
+ pso_t_acc = m_test.get("pso_weights", {}).get("acc")
+ s50_t_nll = m_test.get("single_50e", {}).get("nll")
+ s50_t_acc = m_test.get("single_50e", {}).get("acc")
+
+ if pso_t_nll is not None and s50_t_nll is not None and s50_t_nll > 0:
+ test_rel_nll_reductions.append((s50_t_nll - pso_t_nll) / s50_t_nll)
+ if pso_t_acc is not None and s50_t_acc is not None:
+ test_acc_gains_pp.append(_to_pp(pso_t_acc) - _to_pp(s50_t_acc))
+
+ mean_val_rel_nll = (
+ math.fsum(val_rel_nll_reductions) / len(val_rel_nll_reductions) if val_rel_nll_reductions else 0.0
+ )
+ mean_val_acc_gain = (
+ math.fsum(val_acc_gains_pp) / len(val_acc_gains_pp) if val_acc_gains_pp else 0.0
+ )
+
+ mean_test_rel_nll = (
+ math.fsum(test_rel_nll_reductions) / len(test_rel_nll_reductions) if test_rel_nll_reductions else None
+ )
+ mean_test_acc_gain = (
+ math.fsum(test_acc_gains_pp) / len(test_acc_gains_pp) if test_acc_gains_pp else None
+ )
+
+ if confirmation_pass and mean_test_rel_nll is not None and mean_test_acc_gain is not None:
+ raw_score = 100.0 * mean_test_rel_nll + mean_test_acc_gain
+ else:
+ raw_score = 100.0 * mean_val_rel_nll + mean_val_acc_gain
+
+ score = float(raw_score - 1000.0 * failed_hard_gate_count)
+ if not math.isfinite(score):
+ score = -1000.0 * float(failed_hard_gate_count if failed_hard_gate_count > 0 else 1)
+
+ overall_pass = development_pass and confirmation_pass and (failed_hard_gate_count == 0)
+
+ return {
+ "evaluator_version": EVALUATOR_VERSION,
+ "pass": overall_pass,
+ "score": score,
+ "development_pass": development_pass,
+ "confirmation_pass": confirmation_pass,
+ "failed_hard_gate_count": failed_hard_gate_count,
+ "issues": issues,
+ "development_gates": dev_gates,
+ "confirmation_gates": conf_gates,
+ "metrics": {
+ "mean_val_relative_nll_reduction_vs_equal_budget_single": mean_val_rel_nll,
+ "mean_val_accuracy_gain_vs_equal_budget_single_pp": mean_val_acc_gain,
+ "mean_test_relative_nll_reduction_vs_equal_budget_single": mean_test_rel_nll,
+ "mean_test_accuracy_gain_vs_equal_budget_single_pp": mean_test_acc_gain,
+ },
+ }
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser(
+ description="Strict Evaluator for Post-Training PSO Ensemble Study"
+ )
+ parser.add_argument("--artifact", type=Path, required=True, help="Path to study artifact JSON")
+ parser.add_argument("--output", type=Path, required=True, help="Path to output evaluation JSON")
+ args = parser.parse_args()
+
+ if not args.artifact.is_file():
+ print(f"Error: Artifact file not found at '{args.artifact}'", file=sys.stderr)
+ sys.exit(1)
+
+ try:
+ with args.artifact.open("r", encoding="utf-8") as f:
+ artifact = json.load(f)
+ except Exception as exc:
+ print(f"Error reading artifact JSON: {exc}", file=sys.stderr)
+ sys.exit(1)
+
+ eval_result = evaluate_artifact(artifact)
+
+ save_json_atomic(eval_result, args.output)
+ print(
+ f"Evaluation complete. Pass: {eval_result['pass']}, Score: {eval_result['score']:.6f}, Failed Gates: {eval_result['failed_hard_gate_count']}"
+ )
+ sys.exit(0)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/evaluate_post_training_model_convergence.py b/test/evaluate_post_training_model_convergence.py
new file mode 100644
index 0000000..8a91f4f
--- /dev/null
+++ b/test/evaluate_post_training_model_convergence.py
@@ -0,0 +1,974 @@
+"""Independent evaluator for the post-training model-convergence protocol.
+
+This module is deliberately data-only: it reads JSON manifests, result records and
+stored prediction records. It never imports an adapter, optional detection
+package, dataset, checkpoint, or model. A result is useful only when all of the
+frozen matrix and sealing invariants can be demonstrated from the saved evidence.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import random
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Sequence
+
+EVALUATOR_VERSION = "POST-TRAINING-MODEL-CONVERGENCE-EVALUATOR 1.0.0"
+PROTOCOL_VERSION = "post-training-model-convergence-1.0.0"
+WORKLOADS = ("cifar10_resnet18", "cifar10_resnet50", "voc_yolo11n")
+CLASSIFICATION_WORKLOADS = WORKLOADS[:2]
+DETECTION_WORKLOAD = WORKLOADS[2]
+BASE_SEEDS = (501, 502, 503)
+SWARM_SEEDS = (601, 602, 603)
+SPLIT_SEED = 20260908
+PROJECTION_SEED = 20260909
+BOOTSTRAP_SEED = 20260910
+PARTICLES = 12
+PRIMARY_GENERATIONS = 60
+ENSEMBLE_GENERATIONS = 20
+PRIMARY_QUERIES = PARTICLES * PRIMARY_GENERATIONS
+ENSEMBLE_QUERIES = PARTICLES * ENSEMBLE_GENERATIONS
+PRIMARY_RUNS = len(WORKLOADS) * len(BASE_SEEDS) * len(SWARM_SEEDS)
+ENSEMBLE_RUNS = len(WORKLOADS) * len(SWARM_SEEDS)
+TOTAL_PSO_QUERIES = PRIMARY_RUNS * PRIMARY_QUERIES + ENSEMBLE_RUNS * ENSEMBLE_QUERIES
+OBJECTIVE_SAMPLES = {"cifar10_resnet18": 1024, "cifar10_resnet50": 1024, "voc_yolo11n": 512}
+TOTAL_CANDIDATE_SAMPLES = sum(
+ (len(BASE_SEEDS) * len(SWARM_SEEDS) * PRIMARY_QUERIES + len(SWARM_SEEDS) * ENSEMBLE_QUERIES)
+ * OBJECTIVE_SAMPLES[w] for w in WORKLOADS
+)
+BOOTSTRAP_RESAMPLES = 2000
+BOOTSTRAP_ALPHA = 0.05 / 6.0
+
+ISSUE_CATEGORIES = (
+ "schema", "provenance", "matrix", "accounting", "seal", "selection",
+ "finite", "metrics", "plateau", "overfit", "leakage", "bootstrap", "gates",
+)
+
+
+def _issue(issues: dict[str, list[str]], category: str, message: str) -> None:
+ issues.setdefault(category, []).append(message)
+
+
+def _finite(value: Any) -> bool:
+ return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(float(value))
+
+
+def _walk_nonfinite(value: Any, path: str = "") -> list[str]:
+ out: list[str] = []
+ if isinstance(value, float) and not math.isfinite(value):
+ out.append(path or "$")
+ elif isinstance(value, Mapping):
+ for key, item in value.items():
+ out.extend(_walk_nonfinite(item, f"{path}.{key}" if path else str(key)))
+ elif isinstance(value, (list, tuple)):
+ for i, item in enumerate(value):
+ out.extend(_walk_nonfinite(item, f"{path}[{i}]"))
+ return out
+
+
+def _json(path: Path) -> Any:
+ with path.open("r", encoding="utf-8") as handle:
+ return json.load(handle)
+
+
+def _canonical(value: Any) -> bytes:
+ return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+
+
+def _sha256(path: Path) -> str:
+ digest = hashlib.sha256()
+ with path.open("rb") as handle:
+ for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+ digest.update(chunk)
+ return digest.hexdigest()
+
+
+def _atomic_json(path: Path, value: Any) -> None:
+ path.parent.mkdir(parents=True, exist_ok=True)
+ fd, name = tempfile.mkstemp(prefix=f".{path.name}.", dir=str(path.parent))
+ try:
+ with os.fdopen(fd, "w", encoding="utf-8") as handle:
+ json.dump(value, handle, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+ handle.write("\n")
+ handle.flush()
+ os.fsync(handle.fileno())
+ os.replace(name, path)
+ except BaseException:
+ try:
+ os.unlink(name)
+ except OSError:
+ pass
+ raise
+
+
+def _number(value: Any, *keys: str) -> float | None:
+ if isinstance(value, Mapping):
+ for key in keys:
+ candidate = value.get(key)
+ if _finite(candidate):
+ return float(candidate)
+ for candidate in value.values():
+ found = _number(candidate, *keys)
+ if found is not None:
+ return found
+ elif isinstance(value, (list, tuple)):
+ for candidate in value:
+ found = _number(candidate, *keys)
+ if found is not None:
+ return found
+ return None
+
+
+def _int(value: Any, *keys: str) -> int | None:
+ number = _number(value, *keys)
+ if number is None or not number.is_integer():
+ return None
+ return int(number)
+
+
+def _same(a: Any, b: Any, tol: float = 1e-9) -> bool:
+ return _finite(a) and _finite(b) and math.isclose(float(a), float(b), rel_tol=tol, abs_tol=tol)
+
+
+def _resolve_json(root: Path, value: Any) -> Any:
+ """Resolve a saved JSON prediction reference without opening model/data files."""
+ if isinstance(value, Mapping):
+ for key in ("path", "file", "artifact", "prediction_artifact", "predictions_path"):
+ ref = value.get(key)
+ if isinstance(ref, str) and ref.lower().endswith((".json", ".jsonl", ".pt")):
+ return _resolve_json(root, ref)
+ return value
+ if isinstance(value, str) and value.lower().endswith((".json", ".jsonl", ".pt")):
+ path = (root / value).resolve()
+ if root.resolve() not in path.parents:
+ raise ValueError(f"prediction artifact escapes run root: {value}")
+ if not path.is_file():
+ raise FileNotFoundError(path)
+ if path.suffix == ".jsonl":
+ return [_json_line for _json_line in (json.loads(line) for line in path.read_text(encoding="utf-8").splitlines()) if _json_line]
+ if path.suffix == ".pt":
+ try:
+ import torch
+ return torch.load(path, map_location="cpu", weights_only=True)
+ except (ImportError, OSError, RuntimeError, TypeError, ValueError) as exc:
+ raise ValueError(f"unable to load weights-only prediction artifact: {path}: {exc}") from exc
+ return _json(path)
+ return value
+
+
+def _hash_manifest(root: Path, manifest: Mapping[str, Any], issues: dict[str, list[str]]) -> bool:
+ good = True
+ if manifest.get("protocol_version") != PROTOCOL_VERSION:
+ _issue(issues, "provenance", f"frozen manifest protocol mismatch: {manifest.get('protocol_version')!r}")
+ good = False
+ if manifest.get("state") != "frozen":
+ _issue(issues, "seal", f"frozen manifest state must be 'frozen', got {manifest.get('state')!r}")
+ good = False
+ declared = manifest.get("manifest_hash")
+ payload = {key: manifest[key] for key in ("protocol_version", "config", "artifacts", "state") if key in manifest}
+ if not isinstance(declared, str) or hashlib.sha256(_canonical(payload)).hexdigest() != declared:
+ _issue(issues, "seal", "frozen_manifest.json self-hash mismatch")
+ good = False
+ artifacts = manifest.get("artifacts")
+ if not isinstance(artifacts, Mapping) or not artifacts:
+ _issue(issues, "schema", "frozen manifest requires a non-empty artifacts map")
+ return False
+ for name, expected in artifacts.items():
+ if not isinstance(name, str) or not isinstance(expected, str) or len(expected) != 64:
+ _issue(issues, "schema", f"invalid frozen artifact hash declaration: {name!r}")
+ good = False
+ continue
+ path = (root / name).resolve()
+ if root.resolve() not in path.parents:
+ _issue(issues, "seal", f"frozen artifact escapes run root: {name}")
+ good = False
+ elif not path.is_file():
+ _issue(issues, "seal", f"frozen artifact is missing: {name}")
+ good = False
+ elif _sha256(path) != expected:
+ _issue(issues, "seal", f"frozen artifact hash drift: {name}")
+ good = False
+ return good
+
+
+def _config_checks(config: Any, issues: dict[str, list[str]], workload_id: str | None = None) -> None:
+ if not isinstance(config, Mapping):
+ _issue(issues, "schema", "missing or non-object config")
+ return
+ expected: dict[str, Any] = {
+ "protocol_version": PROTOCOL_VERSION, "split_seed": SPLIT_SEED,
+ "projection_seed": PROJECTION_SEED, "bootstrap_seed": BOOTSTRAP_SEED,
+ "particle_count": PARTICLES, "pso_generations": PRIMARY_GENERATIONS,
+ "residual_dimension": 64, "residual_bound": 1.0, "initial_radius": 0.25,
+ "objective_checkpoints": [0, 10, 20, 30, 40, 50, 60],
+ "base_seeds": list(BASE_SEEDS), "swarm_seeds": list(SWARM_SEEDS),
+ }
+ for key, value in expected.items():
+ got = config.get(key)
+ if got != value and not (isinstance(got, tuple) and list(got) == value):
+ _issue(issues, "provenance", f"config.{key} must be {value!r}, got {got!r}")
+ ids = config.get("workload_ids")
+ if ids is not None and sorted(ids) != sorted(WORKLOADS):
+ _issue(issues, "matrix", f"config.workload_ids must be {list(WORKLOADS)!r}")
+ if workload_id and config.get("workload_id") not in (None, workload_id):
+ _issue(issues, "matrix", f"config.workload_id disagrees with {workload_id}")
+
+
+def _counter(value: Any, keys: Sequence[str]) -> int | None:
+ if not isinstance(value, Mapping):
+ return None
+ for key in keys:
+ candidate = value.get(key)
+ if isinstance(candidate, int) and not isinstance(candidate, bool):
+ return candidate
+ return None
+
+
+def _check_leakage(result: Mapping[str, Any], issues: dict[str, list[str]], workload: str) -> None:
+ leakage = result.get("leakage_counters")
+ if not isinstance(leakage, Mapping):
+ _issue(issues, "schema", f"{workload}: missing leakage_counters")
+ leakage = {}
+ loaded_before = leakage.get("official_test_data_loaded_before_freeze", leakage.get("test_data_loaded_before_freeze"))
+ if loaded_before is not False:
+ _issue(issues, "leakage", f"{workload}: official test data must be explicitly marked not loaded before freeze")
+ evaluated_before = leakage.get("official_test_evaluations_before_freeze", leakage.get("test_evaluations_before_freeze", leakage.get("official_test_forward_passes_before_freeze")))
+ if evaluated_before != 0:
+ _issue(issues, "leakage", f"{workload}: official test exposure before freeze must be explicitly zero")
+ for key in ("official_test_data_loaded_before_freeze", "official_test_evaluations_before_freeze"):
+ if key in result and ((key.endswith("freeze") and result[key] not in (False, 0))):
+ _issue(issues, "leakage", f"{workload}: contradictory top-level {key}")
+ construction = _counter(leakage, ("official_test_construction", "official_test_dataset_construction"))
+ if construction != 1:
+ _issue(issues, "leakage", f"{workload}: official test construction must equal one, got {construction}")
+ forwards = _counter(leakage, ("official_test_forward_passes", "official_test_evaluations"))
+ if forwards is None or forwards < 1:
+ _issue(issues, "leakage", f"{workload}: official test forward/evaluation ledger must be positive, got {forwards}")
+ confirmation = result.get("confirmation")
+ if not isinstance(confirmation, Mapping):
+ _issue(issues, "schema", f"{workload}: missing confirmation record")
+ return
+ for key in ("second_confirmation", "confirmation_repeated", "post_test_tuning", "post_test_reruns"):
+ if confirmation.get(key) not in (None, False, 0, []):
+ _issue(issues, "leakage", f"{workload}: forbidden repeated confirmation/tuning flag {key}")
+ for key in ("official_test_data_loaded_before_freeze", "official_test_evaluations_before_freeze"):
+ if key in confirmation and confirmation[key] not in (False, 0):
+ _issue(issues, "leakage", f"{workload}: confirmation contradicts sealed pre-freeze {key}")
+
+
+def _record_queries(record: Mapping[str, Any]) -> tuple[int | None, int | None]:
+ counters = record.get("counters") if isinstance(record.get("counters"), Mapping) else record
+ queries = _int(counters, "objective_queries", "queries", "query_count", "total_queries", "evaluated_queries")
+ samples = _int(counters, "objective_samples", "samples", "sample_evaluations", "candidate_sample_evaluations", "total_sample_evaluations")
+ return queries, samples
+
+
+def _seed_from_key(key: Any) -> int | None:
+ try:
+ text = str(key)
+ if text.isdigit():
+ return int(text)
+ except Exception:
+ pass
+ return None
+
+
+def _collect_cells(node: Any, base: int | None = None, swarm: int | None = None) -> list[dict[str, Any]]:
+ """Collect cells from either explicit records or base->swarm mappings."""
+ found: list[dict[str, Any]] = []
+ if isinstance(node, Mapping):
+ b = _int(node, "base_seed") if _int(node, "base_seed") is not None else base
+ s = _int(node, "swarm_seed") if _int(node, "swarm_seed") is not None else swarm
+ if s is None:
+ s = _int(node, "seed")
+ if b is not None and s is not None and any(k in node for k in ("counters", "objective_queries", "objective_samples", "queries", "samples", "generation", "endpoint", "metrics")):
+ item = dict(node); item.setdefault("base_seed", b); item.setdefault("swarm_seed", s); found.append(item)
+ for key, value in node.items():
+ key_seed = _seed_from_key(key)
+ if key_seed in BASE_SEEDS:
+ found.extend(_collect_cells(value, key_seed, s))
+ elif key_seed in SWARM_SEEDS:
+ found.extend(_collect_cells(value, b, key_seed))
+ elif key not in {"base_seed", "swarm_seed"}:
+ found.extend(_collect_cells(value, b, s))
+ elif isinstance(node, list):
+ for value in node:
+ found.extend(_collect_cells(value, base, swarm))
+ return found
+
+
+def _collect_base_cells(node: Any, base: int | None = None) -> list[dict[str, Any]]:
+ """Collect one record per base seed from flattened or base->record schemas."""
+ found: list[dict[str, Any]] = []
+ if isinstance(node, Mapping):
+ b = _int(node, "base_seed") if _int(node, "base_seed") is not None else base
+ if b is not None and any(k in node for k in ("updates", "gradient_updates", "counters", "metrics", "checkpoint", "endpoint", "objective")):
+ item = dict(node); item.setdefault("base_seed", b); found.append(item)
+ for key, value in node.items():
+ key_seed = _seed_from_key(key)
+ if key_seed in BASE_SEEDS: found.extend(_collect_base_cells(value, key_seed))
+ elif key not in {"base_seed", "swarm_seed"}: found.extend(_collect_base_cells(value, b))
+ elif isinstance(node, list):
+ for value in node: found.extend(_collect_base_cells(value, base))
+ return found
+
+
+def _method_base_cells(result: Mapping[str, Any], method: str) -> list[dict[str, Any]]:
+ arms = result.get("arms")
+ return _collect_base_cells(arms.get(method)) if isinstance(arms, Mapping) and method in arms else []
+
+
+def _method_evidence(value: Any, method: str, family: str, root: Path) -> bool:
+ """Require non-empty metric or prediction evidence below an exact method key."""
+ if isinstance(value, Mapping):
+ for key, item in value.items():
+ normalized = str(key).lower().replace("-", "_")
+ if normalized == method:
+ if _prediction_records(item, root) is not None: return True
+ if isinstance(item, Mapping) and (_number(item, "nll", "loss", "accuracy", "map50_95", "map50", "mAP50-95") is not None): return True
+ if _method_evidence(item, method, family, root): return True
+ if _method_evidence(item, method, family, root): return True
+ elif isinstance(value, list):
+ return bool(value) and any(_method_evidence(item, method, family, root) for item in value)
+ return False
+
+
+def _require_confirmation_methods(result: Mapping[str, Any], workload: str, family: str, root: Path, issues: dict[str, list[str]]) -> None:
+ confirmation = result.get("confirmation")
+ required = {"feature_pso", "feature_random", "feature_adam", "head_adam"}
+ required |= ({"uniform", "uniform_temperature", "slsqp_weights", "ensemble_pso"} if family == "classification" else {"uniform_wbf", "ensemble_pso", "ensemble_random"})
+ for method in sorted(required):
+ if not _method_evidence(confirmation, method, family, root):
+ _issue(issues, "metrics", f"{workload}: confirmation lacks predictions/metrics for required method {method}")
+
+def _method_cells(result: Mapping[str, Any], method: str) -> list[dict[str, Any]]:
+ arms = result.get("arms")
+ if not isinstance(arms, Mapping):
+ return []
+ value = arms.get(method)
+ return _collect_cells(value) if value is not None else []
+
+
+def _verify_matrix(result: Mapping[str, Any], workload: str, issues: dict[str, list[str]]) -> dict[str, Any]:
+ arms = result.get("arms")
+ if not isinstance(arms, Mapping):
+ _issue(issues, "schema", f"{workload}: arms must be an object")
+ arms = {}
+ required = {"feature_pso", "feature_random", "feature_adam", "head_adam"}
+ missing = required - set(arms)
+ if missing:
+ _issue(issues, "matrix", f"{workload}: missing arms {sorted(missing)}")
+ stats: dict[str, Any] = {"primary_queries": 0, "primary_random_queries": 0, "ensemble_queries": 0, "primary_samples": 0, "primary_random_samples": 0, "ensemble_samples": 0, "cells": {}}
+ for method in ("feature_pso", "feature_random"):
+ cells = _method_cells(result, method)
+ stats["cells"][method] = len(cells)
+ expected = len(BASE_SEEDS) * len(SWARM_SEEDS)
+ if len(cells) != expected:
+ _issue(issues, "matrix", f"{workload}: {method} requires {expected} base/swarm cells, got {len(cells)}")
+ seen: set[tuple[int, int]] = set()
+ for cell in cells:
+ key = (_int(cell, "base_seed") or -1, _int(cell, "swarm_seed") or -1)
+ if key in seen or key[0] not in BASE_SEEDS or key[1] not in SWARM_SEEDS:
+ _issue(issues, "matrix", f"{workload}: invalid or duplicate {method} cell {key}")
+ seen.add(key)
+ queries, samples = _record_queries(cell)
+ if queries != PRIMARY_QUERIES:
+ _issue(issues, "accounting", f"{workload}: {method} {key} queries must be {PRIMARY_QUERIES}, got {queries}")
+ if samples != PRIMARY_QUERIES * OBJECTIVE_SAMPLES[workload]:
+ _issue(issues, "accounting", f"{workload}: {method} {key} samples must be {PRIMARY_QUERIES * OBJECTIVE_SAMPLES[workload]}, got {samples}")
+ if method == "feature_pso":
+ if queries is not None: stats["primary_queries"] += queries
+ if samples is not None: stats["primary_samples"] += samples
+ else:
+ if queries is not None: stats["primary_random_queries"] += queries
+ if samples is not None: stats["primary_random_samples"] += samples
+ for method in ("feature_adam", "head_adam"):
+ cells = _method_base_cells(result, method); stats["cells"][method] = len(cells)
+ if len(cells) != len(BASE_SEEDS): _issue(issues, "matrix", f"{workload}: {method} requires exactly three base cells, got {len(cells)}")
+ seen = set()
+ for cell in cells:
+ seed = _int(cell, "base_seed")
+ if seed in seen or seed not in BASE_SEEDS: _issue(issues, "matrix", f"{workload}: invalid or duplicate {method} base cell {seed}")
+ if seed is not None: seen.add(seed)
+
+ ensemble = result.get("ensemble")
+ if not isinstance(ensemble, Mapping):
+ _issue(issues, "schema", f"{workload}: ensemble must be an object")
+ ensemble = {}
+ required_ensemble = ("uniform", "uniform_temperature", "slsqp_weights", "ensemble_pso") if workload in CLASSIFICATION_WORKLOADS else ("uniform_wbf", "ensemble_pso", "ensemble_random")
+ for method in required_ensemble:
+ if method not in ensemble or ensemble.get(method) in (None, {}, []): _issue(issues, "matrix", f"{workload}: missing required ensemble method {method}")
+ ens_pso = ensemble.get("ensemble_pso", ensemble.get("pso"))
+ cells = _collect_cells(ens_pso) if ens_pso is not None else []
+ stats["cells"]["ensemble_pso"] = len(cells)
+ if len(cells) != len(SWARM_SEEDS):
+ _issue(issues, "matrix", f"{workload}: ensemble_pso requires three swarm cells, got {len(cells)}")
+ seen_swarm: set[int] = set()
+ for cell in cells:
+ seed = _int(cell, "swarm_seed", "seed")
+ if seed in seen_swarm or seed not in SWARM_SEEDS:
+ _issue(issues, "matrix", f"{workload}: invalid or duplicate ensemble swarm cell {seed}")
+ if seed is not None: seen_swarm.add(seed)
+ queries, samples = _record_queries(cell)
+ if queries != ENSEMBLE_QUERIES:
+ _issue(issues, "accounting", f"{workload}: ensemble_pso queries must be {ENSEMBLE_QUERIES}, got {queries}")
+ if samples != ENSEMBLE_QUERIES * OBJECTIVE_SAMPLES[workload]:
+ _issue(issues, "accounting", f"{workload}: ensemble_pso samples must be {ENSEMBLE_QUERIES * OBJECTIVE_SAMPLES[workload]}, got {samples}")
+ if queries is not None: stats["ensemble_queries"] += queries
+ if samples is not None: stats["ensemble_samples"] += samples
+ if workload == DETECTION_WORKLOAD:
+ random_cells = _collect_cells(ensemble.get("ensemble_random")) if ensemble.get("ensemble_random") is not None else []
+ stats["cells"]["ensemble_random"] = len(random_cells)
+ if len(random_cells) != len(SWARM_SEEDS): _issue(issues, "matrix", f"{workload}: ensemble_random requires three swarm cells, got {len(random_cells)}")
+ seen_random = set()
+ for cell in random_cells:
+ seed = _int(cell, "swarm_seed", "seed")
+ if seed in seen_random or seed not in SWARM_SEEDS: _issue(issues, "matrix", f"{workload}: invalid or duplicate ensemble_random seed {seed}")
+ if seed is not None: seen_random.add(seed)
+ return stats
+
+
+def _verify_selection(result: Mapping[str, Any], workload: str, issues: dict[str, list[str]]) -> None:
+ selection = result.get("development_selection")
+ if not isinstance(selection, Mapping):
+ _issue(issues, "selection", f"{workload}: missing development_selection")
+ return
+ selected = selection.get("primary", selection.get("feature_pso", selection.get("selected")))
+ if not isinstance(selected, Mapping):
+ _issue(issues, "selection", f"{workload}: missing primary selected endpoints")
+ return
+ for base in BASE_SEEDS:
+ entry = selected.get(str(base), selected.get(base))
+ if not isinstance(entry, Mapping):
+ _issue(issues, "selection", f"{workload}: no selected endpoint for base seed {base}")
+ continue
+ swarm = _int(entry, "swarm_seed", "seed")
+ generation = _int(entry, "generation", "final_generation")
+ if swarm not in SWARM_SEEDS:
+ _issue(issues, "selection", f"{workload}: selected seed {base} has invalid swarm {swarm}")
+ if generation != PRIMARY_GENERATIONS:
+ _issue(issues, "selection", f"{workload}: selected endpoint {base} is not final generation 60")
+ matches = [c for c in _method_cells(result, "feature_pso") if _int(c, "base_seed") == base and _int(c, "swarm_seed") == swarm]
+ if not matches:
+ _issue(issues, "selection", f"{workload}: selected endpoint {base}/{swarm} is not a feature_pso cell")
+ elif entry.get("vector_hash") and matches[0].get("vector_hash") and entry["vector_hash"] != matches[0]["vector_hash"]:
+ _issue(issues, "selection", f"{workload}: selected vector hash drift for base {base}")
+
+
+def _prediction_records(value: Any, root: Path) -> list[dict[str, Any]] | None:
+ try: value = _resolve_json(root, value)
+ except (OSError, ValueError, json.JSONDecodeError): return None
+ if isinstance(value, Mapping):
+ if "probabilities" in value and "targets" in value:
+ probabilities, targets = value["probabilities"], value["targets"]
+ for attr in ("detach", "cpu"):
+ if hasattr(probabilities, attr): probabilities = getattr(probabilities, attr)()
+ if hasattr(targets, attr): targets = getattr(targets, attr)()
+ if hasattr(probabilities, "tolist"): probabilities = probabilities.tolist()
+ if hasattr(targets, "tolist"): targets = targets.tolist()
+ if isinstance(probabilities, (list, tuple)) and isinstance(targets, (list, tuple)) and len(probabilities) == len(targets):
+ return [{"probabilities": list(probability), "target": int(target)} for probability, target in zip(probabilities, targets)]
+ return None
+ for key in ("records", "predictions", "images", "examples", "data"):
+ if key in value:
+ got = _prediction_records(value[key], root)
+ if got is not None: return got
+ return None
+ if isinstance(value, list) and all(isinstance(x, Mapping) for x in value):
+ return [dict(x) for x in value]
+ return None
+
+
+def _find_prediction_sets(value: Any, root: Path, prefix: str = "$") -> dict[str, list[dict[str, Any]]]:
+ found: dict[str, list[dict[str, Any]]] = {}
+ if isinstance(value, Mapping):
+ for key, item in value.items():
+ name = f"{prefix}.{key}"
+ if "prediction" in str(key).lower() or str(key).lower() in {"base", "pso", "feature_pso", "test"}:
+ records = _prediction_records(item, root)
+ if records is not None: found[name] = records
+ found.update(_find_prediction_sets(item, root, name))
+ elif isinstance(value, list) and value and isinstance(value[0], Mapping):
+ records = _prediction_records(value, root)
+ if records is not None: found[prefix] = records
+ return found
+
+
+def classification_metrics(records: Sequence[Mapping[str, Any]]) -> dict[str, Any]:
+ """Recompute unrounded NLL and accuracy from per-image probabilities/targets."""
+ probs: list[list[float]] = []; targets: list[int] = []
+ for i, record in enumerate(records):
+ p = record.get("probabilities", record.get("probs", record.get("prob")))
+ target = record.get("target", record.get("label", record.get("class_id")))
+ if not isinstance(p, (list, tuple)) or not p or not isinstance(target, int) or isinstance(target, bool) or target < 0 or target >= len(p):
+ raise ValueError(f"invalid classification prediction at index {i}")
+ vals = [float(x) for x in p]
+ if not all(math.isfinite(x) and x >= 0.0 for x in vals) or not math.isclose(math.fsum(vals), 1.0, rel_tol=1e-6, abs_tol=1e-6):
+ raise ValueError(f"probabilities must be finite and sum to one at index {i}")
+ probs.append(vals); targets.append(target)
+ nll = math.fsum(
+ -math.log(max(p[t], 1e-300)) for p, t in zip(probs, targets)
+ ) / len(probs)
+ predictions = [
+ max(range(len(p)), key=p.__getitem__) for p in probs
+ ]
+ accuracy = sum(
+ prediction == target
+ for prediction, target in zip(predictions, targets)
+ ) / len(probs)
+ brier = math.fsum(
+ math.fsum(
+ (probability - float(index == target)) ** 2
+ for index, probability in enumerate(p)
+ )
+ for p, target in zip(probs, targets)
+ ) / len(probs)
+ confidences = [p[prediction] for p, prediction in zip(probs, predictions)]
+ ece = 0.0
+ for bin_index in range(15):
+ lower = bin_index / 15.0
+ upper = (bin_index + 1) / 15.0
+ members = [
+ index
+ for index, confidence in enumerate(confidences)
+ if lower <= confidence <= upper
+ if bin_index == 14 or confidence < upper
+ ]
+ if members:
+ bin_accuracy = math.fsum(
+ predictions[index] == targets[index] for index in members
+ ) / len(members)
+ bin_confidence = math.fsum(
+ confidences[index] for index in members
+ ) / len(members)
+ ece += (
+ abs(bin_accuracy - bin_confidence)
+ * len(members)
+ / len(probs)
+ )
+ return {
+ "n": len(probs),
+ "nll": nll,
+ "accuracy": accuracy,
+ "brier": brier,
+ "ece15": ece,
+ "probabilities": probs,
+ "targets": targets,
+ }
+
+
+def _box(record: Mapping[str, Any]) -> tuple[float, float, float, float] | None:
+ value = record.get("box", record.get("bbox", record.get("xyxy")))
+ if not isinstance(value, (list, tuple)) or len(value) != 4 or not all(_finite(x) for x in value): return None
+ x1, y1, x2, y2 = map(float, value)
+ return (x1, y1, x2, y2) if x2 >= x1 and y2 >= y1 else None
+
+
+def _iou(a: Sequence[float], b: Sequence[float]) -> float:
+ x1, y1 = max(a[0], b[0]), max(a[1], b[1]); x2, y2 = min(a[2], b[2]), min(a[3], b[3])
+ inter = max(0.0, x2 - x1) * max(0.0, y2 - y1)
+ area_a = max(0.0, a[2] - a[0]) * max(0.0, a[3] - a[1]); area_b = max(0.0, b[2] - b[0]) * max(0.0, b[3] - b[1])
+ return inter / (area_a + area_b - inter) if area_a + area_b - inter > 0 else 0.0
+
+
+def _interp_ap_101(recall: Sequence[float], precision: Sequence[float]) -> float:
+ """Ultralytics compute_ap: precision envelope and 101-point trapezoid."""
+ mrec = [0.0, *map(float, recall), 1.0]
+ mpre = [1.0, *map(float, precision), 0.0]
+ for i in range(len(mpre) - 2, -1, -1): mpre[i] = max(mpre[i], mpre[i + 1])
+ values: list[float] = []
+ for k in range(101):
+ x = k / 100.0; j = 0
+ while j + 1 < len(mrec) and mrec[j + 1] <= x: j += 1
+ if j + 1 >= len(mrec): values.append(mpre[-1]); continue
+ span = mrec[j + 1] - mrec[j]
+ values.append(mpre[j] if span <= 0 else mpre[j] + (mpre[j + 1] - mpre[j]) * (x - mrec[j]) / span)
+ return sum((values[i] + values[i + 1]) * 0.5 / 100.0 for i in range(100))
+
+
+def detection_metrics(records: Sequence[Mapping[str, Any]], class_count: int | None = None) -> dict[str, Any]:
+ """Recompute Ultralytics-style whole-dataset AP at IoU .50:.95.
+
+ Matching is performed independently per image. Candidate matches are sorted
+ by IoU and deduplicated by prediction and ground truth, as in
+ DetectionValidator.process_batch; AP then uses the pinned 101-point
+ interpolated trapezoid.
+ """
+ thresholds = [0.50 + 0.05 * i for i in range(10)]
+ parsed: list[tuple[list[dict[str, Any]], list[dict[str, Any]]]] = []; max_class = -1
+ for i, image in enumerate(records):
+ predictions = image.get("predictions", image.get("detections", image.get("pred", [])))
+ truth = image.get("ground_truth", image.get("targets", image.get("gt", image.get("labels", []))))
+ if not isinstance(predictions, list) or not isinstance(truth, list): raise ValueError(f"invalid detection image record {i}")
+ pp: list[dict[str, Any]] = []; gg: list[dict[str, Any]] = []
+ for item in predictions:
+ if not isinstance(item, Mapping) or _box(item) is None: raise ValueError(f"invalid detection prediction {i}")
+ cls = item.get("class_id", item.get("class", item.get("cls"))); score = item.get("score", item.get("confidence", item.get("conf")))
+ if not isinstance(cls, int) or isinstance(cls, bool) or not _finite(score): raise ValueError(f"invalid detection prediction fields {i}")
+ pp.append({"box": _box(item), "class_id": cls, "score": float(score)}); max_class = max(max_class, cls)
+ for item in truth:
+ if not isinstance(item, Mapping) or _box(item) is None: raise ValueError(f"invalid ground truth {i}")
+ cls = item.get("class_id", item.get("class", item.get("cls")))
+ if not isinstance(cls, int) or isinstance(cls, bool): raise ValueError(f"invalid ground truth class {i}")
+ gg.append({"box": _box(item), "class_id": cls}); max_class = max(max_class, cls)
+ parsed.append((pp, gg))
+ present = sorted({g["class_id"] for _, gt in parsed for g in gt})
+ classes = present if class_count is None else [c for c in range(class_count) if c in present]
+ if not classes: classes = list(range(class_count or (max_class + 1))) or [0]
+ aps: dict[str, list[float]] = {}; precision50: list[float] = []; recall50: list[float] = []
+ for cls in classes:
+ gt_count = sum(sum(x["class_id"] == cls for x in gt) for _, gt in parsed); class_aps: list[float] = []
+ for threshold in thresholds:
+ true_by_image: list[list[bool]] = []
+ for preds, gt in parsed:
+ candidates = []
+ for pi, pred in enumerate(preds):
+ if pred["class_id"] != cls: continue
+ for gi, target in enumerate(gt):
+ if target["class_id"] == cls:
+ overlap = _iou(pred["box"], target["box"])
+ if overlap >= threshold: candidates.append((overlap, pi, gi))
+ candidates.sort(key=lambda x: -x[0]); used_pred: set[int] = set(); used_gt: set[int] = set(); matched: set[int] = set()
+ for overlap, pi, gi in candidates:
+ if pi not in used_pred and gi not in used_gt: used_pred.add(pi); used_gt.add(gi); matched.add(pi)
+ true_by_image.append([i in matched for i in range(len(preds))])
+ ranked = sorted(((pred["score"], hit) for (preds, _), hits in zip(parsed, true_by_image) for pred, hit in zip(preds, hits) if pred["class_id"] == cls), key=lambda x: -x[0])
+ tp=[]; fp=[]; ctp=cfp=0
+ for _, hit in ranked:
+ ctp += int(hit); cfp += int(not hit); tp.append(ctp); fp.append(cfp)
+ if gt_count == 0 or not ranked:
+ # Ultralytics ap_per_class skips classes with no predictions; AP is zero.
+ class_aps.append(0.0); continue
+ recalls = [x / gt_count for x in tp]; precisions = [x / max(x + y, 1) for x, y in zip(tp, fp)]
+ class_aps.append(_interp_ap_101(recalls, precisions))
+ if threshold == 0.5:
+ precision50.append(precisions[-1] if precisions else 0.0); recall50.append(recalls[-1] if recalls else 0.0)
+ aps[str(cls)] = class_aps
+ map50 = math.fsum(v[0] for v in aps.values()) / len(aps); map5095 = math.fsum(x for values in aps.values() for x in values) / (len(aps) * 10)
+ return {"per_class_ap": aps, "n": len(records), "map50": map50, "map50_95": map5095,
+ "precision": math.fsum(precision50) / len(precision50) if precision50 else 0.0,
+ "recall": math.fsum(recall50) / len(recall50) if recall50 else 0.0,
+ "ground_truth": sum(len(gt) for _, gt in parsed), "predictions": sum(len(preds) for preds, _ in parsed)}
+
+def _metric_from_record(record: Any, family: str) -> dict[str, float] | None:
+ if not isinstance(record, Mapping): return None
+ keys = ("nll", "loss") if family == "classification" else ("map50_95", "map50-95", "mAP50-95", "map5095")
+ primary = _number(record, *keys); accuracy = _number(record, "accuracy", "acc")
+ map50 = _number(record, "map50", "mAP50")
+ if family == "classification" and primary is not None and accuracy is not None: return {"nll": primary, "accuracy": accuracy}
+ if family == "detection" and primary is not None: return {"map50_95": primary, **({"map50": map50} if map50 is not None else {})}
+ return None
+
+
+def _quantile(values: Sequence[float], q: float) -> float:
+ ordered = sorted(float(x) for x in values)
+ if not ordered: raise ValueError("cannot quantile an empty sequence")
+ position = (len(ordered) - 1) * q; lower = int(math.floor(position)); upper = min(lower + 1, len(ordered) - 1)
+ return ordered[lower] + (ordered[upper] - ordered[lower]) * (position - lower)
+
+
+def _record_identity(record: Mapping[str, Any], index: int) -> Any:
+ for key in ("image_id", "id", "key", "filename", "path", "index"):
+ if key in record: return (key, str(record[key]))
+ return ("position", index)
+
+
+def _record_ground_truth(record: Mapping[str, Any]) -> Any:
+ return record.get("ground_truth", record.get("targets", record.get("gt", record.get("labels", []))))
+
+
+def _bootstrap_alignment(pairs: Sequence[tuple[Sequence[Mapping[str, Any]], Sequence[Mapping[str, Any]]]], family: str) -> tuple[bool, str]:
+ if not pairs or any(len(a) != len(b) or not a for a, b in pairs): return False, "incomplete or length-mismatched paired records"
+ reference_ids = [_record_identity(x, i) for i, x in enumerate(pairs[0][0])]
+ reference_gt = [_record_ground_truth(x) for x in pairs[0][0]]
+ for pair_index, (base, pso) in enumerate(pairs):
+ if [_record_identity(x, i) for i, x in enumerate(base)] != reference_ids or [_record_identity(x, i) for i, x in enumerate(pso)] != reference_ids:
+ return False, f"pair {pair_index} image IDs/order differ"
+ if family == "classification":
+ base_targets = [x.get("target", x.get("label", x.get("class_id"))) for x in base]
+ pso_targets = [x.get("target", x.get("label", x.get("class_id"))) for x in pso]
+ ref_targets = [x.get("target", x.get("label", x.get("class_id"))) for x in pairs[0][0]]
+ if base_targets != ref_targets or pso_targets != ref_targets: return False, f"pair {pair_index} targets differ"
+ elif [_canonical(_record_ground_truth(x)) for x in base] != [_canonical(x) for x in reference_gt] or [_canonical(_record_ground_truth(x)) for x in pso] != [_canonical(x) for x in reference_gt]:
+ return False, f"pair {pair_index} ground truth differs"
+ return True, "aligned"
+
+
+def _bootstrap_from_records(pairs: Sequence[tuple[Sequence[Mapping[str, Any]], Sequence[Mapping[str, Any]]]], family: str) -> dict[str, Any]:
+ aligned, reason = _bootstrap_alignment(pairs, family)
+ if not aligned: return {"available": False, "seed": BOOTSTRAP_SEED, "resamples": BOOTSTRAP_RESAMPLES, "reason": reason}
+ rng = random.Random(BOOTSTRAP_SEED); stats: list[float] = []
+ if family == "classification":
+ parsed = [(classification_metrics(a), classification_metrics(b)) for a, b in pairs]
+ by_class: dict[int, list[int]] = {}
+ for i, target in enumerate(parsed[0][0]["targets"]): by_class.setdefault(target, []).append(i)
+ for _ in range(BOOTSTRAP_RESAMPLES):
+ # One class-stratified draw is shared by every paired base/PSO model.
+ indices = [rng.choice(class_indices) for class_indices in by_class.values() for _ in class_indices]
+ deltas = []
+ for base, pso in parsed:
+ b_nll = math.fsum(-math.log(max(base["probabilities"][i][base["targets"][i]], 1e-300)) for i in indices) / len(indices)
+ p_nll = math.fsum(-math.log(max(pso["probabilities"][i][pso["targets"][i]], 1e-300)) for i in indices) / len(indices)
+ deltas.append((b_nll - p_nll) / b_nll if b_nll else 0.0)
+ stats.append(math.fsum(deltas) / len(deltas))
+ else:
+ for _ in range(BOOTSTRAP_RESAMPLES):
+ # One whole-image draw is shared by every paired base/PSO model.
+ indices = [rng.randrange(len(pairs[0][0])) for _ in pairs[0][0]]
+ deltas = []
+ for base, pso in pairs:
+ b = detection_metrics([base[i] for i in indices])["map50_95"]
+ p = detection_metrics([pso[i] for i in indices])["map50_95"]
+ deltas.append(p - b)
+ stats.append(math.fsum(deltas) / len(deltas))
+ lo = _quantile(stats, BOOTSTRAP_ALPHA); hi = _quantile(stats, 1.0 - BOOTSTRAP_ALPHA)
+ return {"available": True, "seed": BOOTSTRAP_SEED, "resamples": BOOTSTRAP_RESAMPLES, "alpha": BOOTSTRAP_ALPHA, "lower": lo, "upper": hi, "statistic": math.fsum(stats) / len(stats), "excludes_zero": lo > 0 or hi < 0}
+
+def _prediction_pairs(result: Mapping[str, Any], root: Path, family: str) -> list[tuple[int, list[dict[str, Any]], list[dict[str, Any]]]]:
+ """Find one test base/selected pair per frozen base seed by explicit names."""
+ sets = _find_prediction_sets(result.get("confirmation", {}), root)
+ out: list[tuple[int, list[dict[str, Any]], list[dict[str, Any]]]] = []
+ for seed in BASE_SEEDS:
+ candidates = [(name, records) for name, records in sets.items() if str(seed) in name]
+ base = next((records for name, records in candidates if any(x in name.lower() for x in ("base", "frozen"))), None)
+ pso = next((records for name, records in candidates if any(x in name.lower() for x in ("feature_pso", "selected", "pso")) and "ensemble" not in name.lower()), None)
+ if base is not None and pso is not None: out.append((seed, base, pso))
+ return out
+
+
+def _audit_series(value: Any) -> list[dict[str, Any]]:
+ found: list[dict[str, Any]] = []
+ if isinstance(value, Mapping):
+ for item in value.values(): found.extend(_audit_series(item))
+ elif isinstance(value, list) and value and all(isinstance(item, Mapping) for item in value):
+ if any("epoch" in item or "step" in item for item in value) and any(_number(item, "loss", "audit_loss") is not None for item in value):
+ found.append({"records": value})
+ else:
+ for item in value: found.extend(_audit_series(item))
+ return found
+
+
+def _plateau_flags(result: Mapping[str, Any], workload: str, family: str, issues: dict[str, list[str]]) -> dict[str, Any]:
+ baselines = result.get("baselines", {})
+ if not isinstance(baselines, Mapping): return {"available": False, "passed": False}
+ per_seed: dict[str, bool] = {}; details: dict[str, Any] = {}
+ for seed in BASE_SEEDS:
+ entry = baselines.get(str(seed), baselines.get(seed))
+ series = _audit_series(entry)
+ records = series[0]["records"] if series else []
+ records = records[-11:] if len(records) >= 11 else []
+ losses = [_number(x, "loss", "audit_loss") for x in records]
+ metric_keys = ("accuracy", "primary_metric", "selection_accuracy") if family == "classification" else ("map50_95", "mAP50-95", "primary_metric", "selection_metric")
+ metrics = [_number(x, *metric_keys) for x in records]
+ loss_ok = len(losses) == 11 and all(x is not None for x in losses)
+ metric_ok = len(metrics) == 11 and all(x is not None for x in metrics)
+ if loss_ok:
+ mean = math.fsum(float(x) for x in losses) / len(losses)
+ loss_ok = (max(losses) - min(losses)) / max(abs(mean), 1e-12) <= 0.01
+ if metric_ok: metric_ok = max(metrics) - min(metrics) <= 0.005
+ passed = bool(loss_ok and metric_ok); per_seed[str(seed)] = passed
+ details[str(seed)] = {"loss_ok": bool(loss_ok), "metric_ok": bool(metric_ok), "observations": len(records)}
+ declared = _number(entry, "baseline_plateau") if isinstance(entry, Mapping) else None
+ if isinstance(entry, Mapping) and "baseline_plateau" in entry and bool(entry["baseline_plateau"]) != passed:
+ _issue(issues, "plateau", f"{workload}: baseline seed {seed} inflated/incorrect plateau flag")
+ return {"available": bool(per_seed), "per_seed": per_seed, "details": details, "passed": bool(per_seed) and all(per_seed.values())}
+
+
+def _workload_gates(result: Mapping[str, Any], workload: str, family: str, root: Path, issues: dict[str, list[str]]) -> dict[str, Any]:
+ pairs = _prediction_pairs(result, root, family)
+ per_seed: dict[str, Any] = {}
+ pair_records: list[tuple[Sequence[Mapping[str, Any]], Sequence[Mapping[str, Any]]]] = []
+ for seed, base_records, pso_records in pairs:
+ try:
+ base = classification_metrics(base_records) if family == "classification" else detection_metrics(base_records, 20)
+ pso = classification_metrics(pso_records) if family == "classification" else detection_metrics(pso_records, 20)
+ except (ValueError, ZeroDivisionError) as exc:
+ _issue(issues, "metrics", f"{workload}: test pair {seed} cannot be recomputed: {exc}"); continue
+ pair_records.append((base_records, pso_records))
+ if family == "classification": per_seed[str(seed)] = {"base": {"nll": base["nll"], "accuracy": base["accuracy"]}, "pso": {"nll": pso["nll"], "accuracy": pso["accuracy"]}, "relative_nll_reduction": (base["nll"] - pso["nll"]) / base["nll"], "accuracy_delta": pso["accuracy"] - base["accuracy"]}
+ else: per_seed[str(seed)] = {"base": {"map50_95": base["map50_95"], "map50": base["map50"]}, "pso": {"map50_95": pso["map50_95"], "map50": pso["map50"]}, "map50_95_delta": pso["map50_95"] - base["map50_95"], "map50_delta": pso["map50"] - base["map50"]}
+ ci = _bootstrap_from_records(pair_records, family)
+ # Confirmation predictions and the paired CI are required integrity evidence.
+ # A numerically negative CI is a valid scientific result; an unavailable CI
+ # means the frozen/confirmed artifact set is incomplete or tampered.
+ if len(pairs) != len(BASE_SEEDS):
+ _issue(issues, "metrics", f"{workload}: required confirmation pairs are incomplete ({len(pairs)}/{len(BASE_SEEDS)})")
+ if not ci.get("available", False):
+ _issue(issues, "metrics", f"{workload}: required paired bootstrap unavailable: {ci.get('reason', 'missing prediction evidence')}")
+ if family == "classification" and per_seed:
+ reductions = [x["relative_nll_reduction"] for x in per_seed.values()]; acc_deltas = [x["accuracy_delta"] for x in per_seed.values()]
+ gate = len(reductions) == 3 and math.fsum(reductions) / 3 >= 0.01 and math.fsum(acc_deltas) / 3 >= -0.002 and min(acc_deltas) >= -0.005 and sum(x > 0 for x in reductions) >= 2 and ci.get("excludes_zero", False)
+ elif family == "detection" and per_seed:
+ deltas = [x["map50_95_delta"] for x in per_seed.values()]
+ gate = len(deltas) == 3 and math.fsum(deltas) / 3 >= 0.005 and min(deltas) >= -0.005 and sum(x > 0 for x in deltas) >= 2 and ci.get("excludes_zero", False)
+ else: gate = False
+ if len(pairs) != len(BASE_SEEDS): _issue(issues, "bootstrap", f"{workload}: missing complete official-test base/feature_pso prediction pairs ({len(pairs)}/3)")
+ return {"available": bool(per_seed), "per_seed": per_seed, "bootstrap": ci, "generalization_pass": bool(gate)}
+
+
+def _verify_hashes(result: Mapping[str, Any], root: Path, issues: dict[str, list[str]], workload: str) -> None:
+ declared = result.get("artifact_hashes")
+ if not isinstance(declared, Mapping):
+ _issue(issues, "schema", f"{workload}: missing artifact_hashes")
+ return
+ for name, expected in declared.items():
+ if not isinstance(name, str) or not isinstance(expected, str):
+ _issue(issues, "seal", f"{workload}: malformed artifact hash entry")
+ continue
+ path = (root / name).resolve()
+ if root.resolve() not in path.parents or not path.is_file():
+ _issue(issues, "seal", f"{workload}: missing/escaping artifact {name}")
+ elif _sha256(path) != expected:
+ _issue(issues, "seal", f"{workload}: artifact hash drift {name}")
+
+
+def _compare_development_snapshot(development: Any, current: Mapping[str, Any], workload: str, issues: dict[str, list[str]]) -> None:
+ """Ensure confirmation did not alter any sealed development decision/state."""
+ if not isinstance(development, Mapping):
+ _issue(issues, "schema", f"{workload}: development_result.json must contain an object")
+ return
+ development_leakage = development.get("leakage_counters")
+ if not isinstance(development_leakage, Mapping):
+ _issue(issues, "leakage", f"{workload}: development snapshot lacks leakage_counters")
+ else:
+ loaded = development_leakage.get("official_test_data_loaded_before_freeze", development_leakage.get("test_data_loaded_before_freeze"))
+ evaluated = development_leakage.get("official_test_evaluations_before_freeze", development_leakage.get("test_evaluations_before_freeze", development_leakage.get("official_test_forward_passes_before_freeze")))
+ if loaded is not False or evaluated != 0:
+ _issue(issues, "leakage", f"{workload}: development snapshot records pre-freeze official-test exposure")
+ for key in ("official_test_construction", "official_test_dataset_construction", "official_test_forward_passes", "official_test_evaluations"):
+ if key in development_leakage and development_leakage[key] != 0:
+ _issue(issues, "leakage", f"{workload}: development snapshot {key} must be zero")
+ development_confirmation = development.get("confirmation")
+ if development_confirmation not in ({}, None):
+ _issue(issues, "leakage", f"{workload}: development snapshot confirmation must be empty")
+ fields = ("config", "manifests", "provenance", "baselines", "arms", "ensemble", "development_selection", "integrity", "resource_ledger", "artifact_hashes")
+ for field in fields:
+ if field not in development:
+ _issue(issues, "seal", f"{workload}: development_result.json missing sealed field {field}")
+ continue
+ if field not in current:
+ _issue(issues, "seal", f"{workload}: current result missing sealed field {field}")
+ continue
+ if field == "artifact_hashes":
+ # Confirmation may add test prediction hashes. Every development hash
+ # must nevertheless remain present and byte-identical.
+ old_hashes = development[field]; new_hashes = current[field]
+ if not isinstance(old_hashes, Mapping) or not isinstance(new_hashes, Mapping):
+ _issue(issues, "seal", f"{workload}: artifact_hashes changed shape across confirmation")
+ else:
+ for name, value in old_hashes.items():
+ if new_hashes.get(name) != value: _issue(issues, "seal", f"{workload}: sealed artifact hash drift for {name}")
+ elif field == "integrity":
+ old_integrity = development[field]; new_integrity = current[field]
+ if not isinstance(old_integrity, Mapping) or not isinstance(new_integrity, Mapping):
+ if old_integrity != new_integrity: _issue(issues, "seal", f"{workload}: pre-confirmation integrity changed")
+ else:
+ for name, value in old_integrity.items():
+ if new_integrity.get(name) != value: _issue(issues, "seal", f"{workload}: pre-confirmation integrity field changed: {name}")
+ elif _canonical(development[field]) != _canonical(current[field]):
+ _issue(issues, "seal", f"{workload}: sealed pre-confirmation field changed: {field}")
+
+def _evaluate_workload(result: Any, root: Path, workload: str, issues: dict[str, list[str]], development: Any = None) -> dict[str, Any]:
+ if not isinstance(result, Mapping):
+ _issue(issues, "schema", f"{workload}: result must be an object"); return {"workload_id": workload, "valid": False}
+ if result.get("workload_id") != workload: _issue(issues, "matrix", f"{workload}: workload_id mismatch")
+ if development is not None: _compare_development_snapshot(development, result, workload, issues)
+ family = "detection" if workload == DETECTION_WORKLOAD else "classification"
+ if result.get("family") != family: _issue(issues, "matrix", f"{workload}: family must be {family}")
+ for key in ("manifests", "provenance", "baselines", "arms", "ensemble", "development_selection", "confirmation", "integrity", "leakage_counters", "resource_ledger", "artifact_hashes"):
+ if key not in result: _issue(issues, "schema", f"{workload}: missing top-level {key}")
+ _config_checks(result.get("config"), issues, workload); _check_leakage(result, issues, workload); _verify_hashes(result, root, issues, workload)
+ accounting = _verify_matrix(result, workload, issues); _verify_selection(result, workload, issues); _require_confirmation_methods(result, workload, family, root, issues)
+ if result.get("integrity", {}).get("confirmed") is False if isinstance(result.get("integrity"), Mapping) else False:
+ _issue(issues, "seal", f"{workload}: integrity declares confirmation failure")
+ prediction_sets = _find_prediction_sets(result.get("confirmation", {}), root)
+ recomputed: dict[str, Any] = {}
+ for name, records in prediction_sets.items():
+ try: recomputed[name] = classification_metrics(records) if family == "classification" else detection_metrics(records, 20)
+ except (ValueError, ZeroDivisionError) as exc: _issue(issues, "metrics", f"{workload}: invalid stored predictions at {name}: {exc}")
+ # Check every explicitly stored metric that has a corresponding recomputation.
+ for name, metric in recomputed.items():
+ if "pso" in name.lower() and isinstance(metric, Mapping):
+ stored = _metric_from_record(result.get("confirmation"), family)
+ if stored and family == "classification" and not (_same(stored.get("nll"), metric.get("nll"), 1e-7) and _same(stored.get("accuracy"), metric.get("accuracy"), 1e-7)):
+ _issue(issues, "metrics", f"{workload}: stored classification metric disagrees with probabilities at {name}")
+ plateau = _plateau_flags(result, workload, family, issues)
+ gates = _workload_gates(result, workload, family, root, issues)
+ objective = _number(result.get("development_selection"), "objective_improvement", "relative_objective_improvement")
+ selection_metric = _number(result.get("development_selection"), "selection_metric", "selection_nll", "selection_map50_95")
+ overfit = bool(objective is not None and objective >= 0.01 and selection_metric is not None and ((family == "classification" and selection_metric > 0.01) or (family == "detection" and selection_metric < -0.005)))
+ if overfit: _issue(issues, "overfit", f"{workload}: objective improvement conflicts with held-out/selection metric")
+ return {"workload_id": workload, "family": family, "valid": True, "accounting": accounting, "recomputed": recomputed, "plateau": plateau, "gates": gates, "overfit_signal": overfit}
+
+
+def evaluate_run(run_root: str | os.PathLike[str]) -> dict[str, Any]:
+ """Evaluate one frozen run, returning findings even when artifacts are malformed."""
+ root = Path(run_root); issues = {key: [] for key in ISSUE_CATEGORIES}; workloads: dict[str, Any] = {}
+ manifest: Any = None
+ try: manifest = _json(root / "frozen_manifest.json")
+ except (OSError, ValueError, json.JSONDecodeError) as exc: _issue(issues, "schema", f"cannot load frozen_manifest.json: {exc}")
+ if isinstance(manifest, Mapping):
+ for location in _walk_nonfinite(manifest): _issue(issues, "finite", f"non-finite value in frozen manifest at {location}")
+ _hash_manifest(root, manifest, issues); _config_checks(manifest.get("config"), issues)
+ frozen_config = manifest.get("config") if isinstance(manifest.get("config"), Mapping) else {}
+ if sorted(frozen_config.get("workload_ids", ())) != sorted(WORKLOADS): _issue(issues, "matrix", "frozen manifest does not seal all three workloads")
+ for workload in WORKLOADS:
+ path = root / "workloads" / workload / "result.json"
+ development_path = root / "workloads" / workload / "development_result.json"
+ if isinstance(manifest, Mapping):
+ manifest_artifacts = manifest.get("artifacts", {})
+ expected_development = f"workloads/{workload}/development_result.json"
+ if not isinstance(manifest_artifacts, Mapping) or expected_development not in manifest_artifacts:
+ _issue(issues, "seal", f"{workload}: frozen manifest must seal {expected_development}")
+ try: result = _json(path)
+ except (OSError, ValueError, json.JSONDecodeError) as exc:
+ _issue(issues, "schema", f"{workload}: cannot load result.json: {exc}"); continue
+ try: development = _json(development_path)
+ except (OSError, ValueError, json.JSONDecodeError) as exc:
+ _issue(issues, "seal", f"{workload}: cannot load development_result.json: {exc}"); development = None
+ for location in _walk_nonfinite(result): _issue(issues, "finite", f"{workload}: non-finite value at {location}")
+ if development is not None:
+ for location in _walk_nonfinite(development): _issue(issues, "finite", f"{workload}: non-finite development value at {location}")
+ workloads[workload] = _evaluate_workload(result, root, workload, issues, development)
+ # Cross-workload exact accounting is intentionally independent of stored totals.
+ totals = {key: sum(int(w.get("accounting", {}).get(key, 0)) for w in workloads.values()) for key in ("primary_queries", "primary_random_queries", "ensemble_queries", "primary_samples", "primary_random_samples", "ensemble_samples")}
+ totals["pso_queries"] = totals["primary_queries"] + totals["ensemble_queries"]
+ totals["candidate_samples"] = totals["primary_samples"] + totals["ensemble_samples"]
+ if totals["pso_queries"] != TOTAL_PSO_QUERIES: _issue(issues, "accounting", f"total PSO queries must be {TOTAL_PSO_QUERIES}, got {totals['pso_queries']}")
+ if totals["candidate_samples"] != TOTAL_CANDIDATE_SAMPLES: _issue(issues, "accounting", f"total candidate-sample evaluations must be {TOTAL_CANDIDATE_SAMPLES}, got {totals['candidate_samples']}")
+ # A success flag is never consumed; it is checked against independently observed integrity.
+ integrity_ok = not any(issues[key] for key in ("schema", "provenance", "matrix", "accounting", "seal", "selection", "finite", "leakage", "metrics"))
+ payload = {"evaluator_version": EVALUATOR_VERSION, "protocol_version": PROTOCOL_VERSION, "run_root": str(root), "pass": integrity_ok, "integrity_pass": integrity_ok, "workloads": workloads, "accounting": {**totals, "expected_pso_queries": TOTAL_PSO_QUERIES, "expected_candidate_samples": TOTAL_CANDIDATE_SAMPLES}, "issues": issues, "issue_counts": {key: len(value) for key, value in issues.items()}}
+ return payload
+
+
+def build_cli_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(description="Evaluate frozen post-training model-convergence artifacts")
+ parser.add_argument("--run-root", type=Path, required=True)
+ parser.add_argument("--output", type=Path, default=None)
+ return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+ args = build_cli_parser().parse_args(argv); payload = evaluate_run(args.run_root)
+ destination = args.output or args.run_root / "evaluation.json"
+ try: _atomic_json(destination, payload)
+ except OSError as exc:
+ print(f"evaluator output failed: {exc}", file=sys.stderr); return 2
+ print(json.dumps(payload, sort_keys=True, separators=(",", ":")))
+ return 0 if payload["pass"] else 1
+
+
+__all__ = [
+ "BASE_SEEDS", "BOOTSTRAP_ALPHA", "BOOTSTRAP_RESAMPLES", "BOOTSTRAP_SEED", "CLASSIFICATION_WORKLOADS",
+ "DETECTION_WORKLOAD", "EVALUATOR_VERSION", "ENSEMBLE_QUERIES", "TOTAL_CANDIDATE_SAMPLES", "TOTAL_PSO_QUERIES",
+ "WORKLOADS", "classification_metrics", "detection_metrics", "evaluate_run", "main", "build_cli_parser",
+]
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/test/fashion_mnist.py b/test/fashion_mnist.py
index e0af751..b4ace1e 100644
--- a/test/fashion_mnist.py
+++ b/test/fashion_mnist.py
@@ -1,87 +1,110 @@
-# %%
-import json
-import os
-import sys
+import argparse
+import torch
+import torch.nn as nn
-import numpy as np
-import tensorflow as tf
-from keras.datasets import fashion_mnist
-from keras.layers import Conv2D, Dense, Dropout, Flatten, MaxPooling2D
-from keras.models import Sequential
-
-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():
- (x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()
+def get_data(seed: int = 42):
+ from sklearn.decomposition import PCA
+ from torchvision.datasets import FashionMNIST
- x_train, x_test = x_train / 255.0, x_test / 255.0
- x_train = x_train.reshape((60000, 28, 28, 1))
- x_test = x_test.reshape((10000, 28, 28, 1))
+ train_dataset = FashionMNIST(root="./data", train=True, download=True)
+ test_dataset = FashionMNIST(root="./data", train=False, download=True)
- y_train, y_test = tf.one_hot(y_train, 10), tf.one_hot(y_test, 10)
+ x_train_raw = (train_dataset.data[:3000].float() / 255.0).reshape(3000, -1).numpy()
+ y_train = train_dataset.targets[:3000].long()
- x_train, x_test = tf.convert_to_tensor(x_train), tf.convert_to_tensor(x_test)
- y_train, y_test = tf.convert_to_tensor(y_train), tf.convert_to_tensor(y_test)
+ x_test_raw = (test_dataset.data[:1000].float() / 255.0).reshape(1000, -1).numpy()
+ y_test = test_dataset.targets[:1000].long()
- print(f"x_train : {x_train[0].shape} | y_train : {y_train[0].shape}")
- print(f"x_test : {x_test[0].shape} | y_test : {y_test[0].shape}")
+ pca = PCA(n_components=32, whiten=True, random_state=seed)
+ x_train_pca = pca.fit_transform(x_train_raw)
+ x_test_pca = pca.transform(x_test_raw)
+
+ x_train = torch.tensor(x_train_pca, dtype=torch.float32)
+ x_test = torch.tensor(x_test_pca, dtype=torch.float32)
+
+ print(f"x_train : {x_train.shape} | y_train : {y_train.shape}")
+ print(f"x_test : {x_test.shape} | y_test : {y_test.shape}")
return x_train, y_train, x_test, y_test
-def make_model():
- model = Sequential()
- model.add(
- Conv2D(32, kernel_size=(5, 5), activation="relu", input_shape=(28, 28, 1))
+def make_model(seed: int = 42):
+ torch.manual_seed(seed)
+ return nn.Linear(32, 10)
+
+
+def main():
+ parser = argparse.ArgumentParser(description="PSO Fashion-MNIST Benchmark Script")
+ add_pso_args(
+ parser,
+ defaults={
+ "method": "original",
+ "initialization": "model_noise",
+ "evaluation": "fixed_subset",
+ "convergence": "particle_reset",
+ "refinement": "adam",
+ "n_particles": 30,
+ "c0": None,
+ "c1": None,
+ "w_min": None,
+ "w_max": None,
+ "negative_swarm": 0.0,
+ "mutation_swarm": 0.05,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "velocity_limit_ratio": 0.1,
+ "boundary_strategy": "reflect",
+ "seed": 42,
+ "epochs": 80,
+ "batch_size": 1000,
+ "fitness_size": 2000,
+ "renewal": "loss",
+ "output_dir": "output/fashion_mnist",
+ "checkpoint_interval": 25,
+ "refinement_epochs": 10,
+ "refinement_lr": 0.001,
+ },
)
- model.add(MaxPooling2D(pool_size=(2, 2)))
- model.add(Conv2D(64, kernel_size=(3, 3), activation="relu"))
- model.add(MaxPooling2D(pool_size=(2, 2)))
- model.add(Flatten())
- model.add(Dropout(0.25))
- model.add(Dense(256, activation="relu"))
- model.add(Dense(128, activation="relu"))
- model.add(Dense(10, activation="softmax"))
+ 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.7, "c1": 0.5, "w_min": 0.1, "w_max": 0.8},
+ )
+ pso_fashion = Optimizer(**kwargs)
+
+ print(f"Optimizer device: {pso_fashion.device}")
+
+ best_score = pso_fashion.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()
-
-
-pso_mnist = optimizer(
- model,
- loss="categorical_crossentropy",
- n_particles=200,
- c0=0.7,
- c1=0.5,
- w_min=0.1,
- w_max=0.8,
- negative_swarm=0.0,
- mutation_swarm=0.05,
- convergence_reset=True,
- convergence_reset_patience=10,
- convergence_reset_monitor="loss",
-)
-
-best_score = pso_mnist.fit(
- x_train,
- y_train,
- epochs=1000,
- save_info=True,
- log=2,
- log_name="fashion_mnist",
- renewal="loss",
- check_point=25,
- batch_size=5000,
-)
-
-print("Done!")
-
-sys.exit(0)
-
+if __name__ == "__main__":
+ main()
diff --git a/test/fashion_mnist_tf.py b/test/fashion_mnist_tf.py
deleted file mode 100644
index 988d79e..0000000
--- a/test/fashion_mnist_tf.py
+++ /dev/null
@@ -1,115 +0,0 @@
-from keras.models import Sequential
-from keras.layers import Conv2D, Dense, Dropout, Flatten, MaxPooling2D
-from keras.datasets import mnist, fashion_mnist
-from keras.utils import to_categorical
-# from tensorflow.data.Dataset import from_tensor_slices
-import tensorflow as tf
-import os
-
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
-
-
-gpus = tf.config.experimental.list_physical_devices("GPU")
-if gpus:
- try:
- tf.config.experimental.set_memory_growth(gpus[0], True)
- except Exception as e:
- print(e)
- finally:
- del gpus
-
-
-def get_data():
- (x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()
- print(f"y_train : {y_train[0]} | y_test : {y_test[0]}")
-
- x_train, x_test = x_train / 255.0, x_test / 255.0
- x_train = x_train.reshape((60000, 28, 28, 1))
- x_test = x_test.reshape((10000, 28, 28, 1))
-
- print(f"x_train : {x_train[0].shape} | y_train : {y_train[0].shape}")
- print(f"x_test : {x_test[0].shape} | y_test : {y_test[0].shape}")
-
- return x_train, y_train, x_test, y_test
-
-
-class _batch_generator:
- def __init__(self, x, y, batch_size: int = 32):
- self.batch_size = batch_size
- self.index = 0
- self.x = x
- self.y = y
- self.setBatchSize(batch_size)
-
- def next(self):
- self.index += 1
- if self.index >= self.max_index:
- self.index = 0
- return self.dataset[self.index][0], self.dataset[self.index][1]
-
- def getMaxIndex(self):
- return self.max_index
-
- def getIndex(self):
- return self.index
-
- def setIndex(self, index):
- self.index = index
-
- def getBatchSize(self):
- return self.batch_size
-
- def setBatchSize(self, batch_size):
- self.batch_size = batch_size
- self.dataset = list(
- tf.data.Dataset.from_tensor_slices(
- (self.x, self.y)).batch(batch_size)
- )
- self.max_index = len(self.dataset)
-
- def getDataset(self):
- return self.dataset
-
-
-def make_model():
- model = Sequential()
- model.add(
- Conv2D(32, kernel_size=(5, 5), activation="sigmoid",
- input_shape=(28, 28, 1))
- )
- model.add(MaxPooling2D(pool_size=(2, 2)))
- model.add(Conv2D(64, kernel_size=(3, 3), activation="sigmoid"))
- model.add(MaxPooling2D(pool_size=(2, 2)))
- model.add(Flatten())
- model.add(Dropout(0.25))
- model.add(Dense(128, activation="sigmoid"))
- model.add(Dense(10, activation="softmax"))
-
- return model
-
-
-model = make_model()
-x_train, y_train, x_test, y_test = get_data()
-print(x_train.shape)
-y_train = tf.one_hot(y_train, 10)
-y_test = tf.one_hot(y_test, 10)
-
-dataset = _batch_generator(x_train, y_train, 32)
-
-model.compile(optimizer="adam", loss="mse", metrics=["accuracy"])
-
-count = 0
-
-while count < 100:
- x_batch, y_batch = dataset.next()
- count += 1
- print("Training model...")
- model.fit(x_batch, y_batch, epochs=1, batch_size=1, verbose=1)
-
-print(count)
-print(f"Max index : {dataset.getMaxIndex()}")
-
-print("Evaluating model...")
-model.evaluate(x_test, y_test, verbose=2)
-
-weights = model.get_weights()
diff --git a/test/fashion_mnist_torch.py b/test/fashion_mnist_torch.py
new file mode 100644
index 0000000..6d386e3
--- /dev/null
+++ b/test/fashion_mnist_torch.py
@@ -0,0 +1,129 @@
+"""Fashion-MNIST dataset gradient baseline (PyTorch standard backprop optimizer, non-PSO)."""
+
+import copy
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+
+class FashionMNISTModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.conv1 = nn.Conv2d(1, 32, kernel_size=5)
+ self.sig1 = nn.Sigmoid()
+ self.pool1 = nn.MaxPool2d(2, 2)
+
+ self.conv2 = nn.Conv2d(32, 64, kernel_size=3)
+ self.sig2 = nn.Sigmoid()
+ self.pool2 = nn.MaxPool2d(2, 2)
+
+ self.drop = nn.Dropout(0.25)
+ self.fc1 = nn.Linear(64 * 5 * 5, 128)
+ self.sig3 = nn.Sigmoid()
+ self.fc2 = nn.Linear(128, 10)
+
+ def forward(self, x):
+ x = self.pool1(self.sig1(self.conv1(x)))
+ x = self.pool2(self.sig2(self.conv2(x)))
+ x = torch.flatten(x, 1)
+ x = self.drop(x)
+ x = self.sig3(self.fc1(x))
+ x = self.fc2(x)
+ return x
+
+
+def get_data(download: bool = True):
+ from torchvision import datasets, transforms
+
+ transform = transforms.ToTensor()
+ train_dataset = datasets.FashionMNIST(
+ root="./data", train=True, transform=transform, download=download
+ )
+ test_dataset = datasets.FashionMNIST(
+ root="./data", train=False, transform=transform, download=download
+ )
+ return train_dataset, test_dataset
+
+
+def get_device() -> torch.device:
+ if (
+ hasattr(torch.backends, "mps")
+ and torch.backends.mps.is_built()
+ and torch.backends.mps.is_available()
+ ):
+ return torch.device("mps")
+ elif torch.cuda.is_available():
+ return torch.device("cuda")
+ return torch.device("cpu")
+
+
+def main():
+ torch.manual_seed(42)
+ np.random.seed(42)
+
+ device = get_device()
+ print(f"Selected device: {device}")
+
+ train_dataset, test_dataset = get_data(download=True)
+ train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
+ test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)
+
+ model = FashionMNISTModel().to(device)
+ optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+ criterion = nn.CrossEntropyLoss()
+
+ best_val_loss = float("inf")
+ best_state = None
+
+ for epoch in range(10):
+ model.train()
+ for bx, by in train_loader:
+ bx, by = bx.to(device), by.to(device)
+ optimizer.zero_grad()
+ out = model(bx)
+ loss = criterion(out, by)
+ loss.backward()
+ optimizer.step()
+
+ model.eval()
+ val_loss = 0.0
+ total = 0
+ with torch.no_grad():
+ for bx, by in test_loader:
+ bx, by = bx.to(device), by.to(device)
+ out = model(bx)
+ loss = criterion(out, by)
+ val_loss += loss.item() * bx.size(0)
+ total += bx.size(0)
+
+ val_loss /= total
+
+ if val_loss < best_val_loss:
+ best_val_loss = val_loss
+ best_state = copy.deepcopy(model.state_dict())
+
+ if best_state is not None:
+ model.load_state_dict(best_state)
+
+ model.eval()
+ test_loss = 0.0
+ correct = 0
+ total = 0
+ with torch.no_grad():
+ for bx, by in test_loader:
+ bx, by = bx.to(device), by.to(device)
+ out = model(bx)
+ loss = criterion(out, by)
+ test_loss += loss.item() * bx.size(0)
+ preds = out.argmax(dim=1)
+ correct += (preds == by).sum().item()
+ total += bx.size(0)
+
+ test_loss /= total
+ test_acc = correct / total
+ print(f"Final test loss: {test_loss:.4f}, accuracy: {test_acc:.4f}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/full_mnist_study.py b/test/full_mnist_study.py
new file mode 100644
index 0000000..b62e9fd
--- /dev/null
+++ b/test/full_mnist_study.py
@@ -0,0 +1,707 @@
+"""
+Full-MNIST 60k/10k Particle Swarm Optimization Trajectory Analysis
+
+Evaluates the selected Adaptive Moment PSO configuration on full official MNIST (60,000 train / 10,000 test)
+across 120 particles for 240 continuous epochs, scoring all 60,000 training examples for every particle
+at every epoch.
+
+Predeclared Diagnostic Criteria:
+1. Post-80 Training Convergence: Mean training loss falls >= 1% from epoch 80 to epoch 240.
+2. Epoch 240 Test Gain: Mean test accuracy at epoch 240 rises >= 1 percentage point vs epoch 80.
+3. Late Plateau (200->240): Training loss improvement < 1% AND absolute test accuracy change < 0.5 percentage points.
+"""
+
+import argparse
+import csv
+import datetime
+import json
+import math
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+
+# Ensure test/ directory is in sys.path
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from benchmark_suite import (
+ calc_stats,
+ extract_plugin_metadata,
+ compute_data_fingerprint,
+ compute_model_fingerprint,
+ get_hardware_provenance,
+ make_mnist_model,
+ resolve_execution_device,
+ save_json_atomic,
+ sync_device,
+)
+from pso import Optimizer, __version__ as pso_version
+from reproduce_scaling import validate_and_load_baseline
+
+FULL_MNIST_PROTOCOL_VERSION = "1.0.0"
+
+
+def prepare_full_mnist_data() -> Tuple[
+ torch.Tensor,
+ torch.Tensor,
+ torch.Tensor,
+ torch.Tensor,
+ str,
+ Dict[str, Any],
+]:
+ """
+ Load official torchvision MNIST full train (60,000) and test (10,000).
+ Normalize pixels, flatten to 784, fit PCA(n_components=32, whiten=True, random_state=42)
+ on train only, transform test. Validate 60,000/10,000 sample counts and label range [0, 9].
+ """
+ from torchvision.datasets import MNIST
+ from sklearn.decomposition import PCA
+
+ cache_dir = Path("result/cache")
+ cache_dir.mkdir(parents=True, exist_ok=True)
+ train_dataset = MNIST(root=str(cache_dir), train=True, download=True)
+ test_dataset = MNIST(root=str(cache_dir), train=False, download=True)
+
+ n_train = len(train_dataset.data)
+ n_test = len(test_dataset.data)
+ if n_train != 60000:
+ raise ValueError(f"Expected 60,000 training samples; got {n_train}")
+ if n_test != 10000:
+ raise ValueError(f"Expected 10,000 test samples; got {n_test}")
+
+ y_train_60000 = train_dataset.targets.long()
+ y_test_10000 = test_dataset.targets.long()
+
+ min_tr_lbl, max_tr_lbl = int(y_train_60000.min()), int(y_train_60000.max())
+ min_te_lbl, max_te_lbl = int(y_test_10000.min()), int(y_test_10000.max())
+
+ if min_tr_lbl != 0 or max_tr_lbl != 9:
+ raise ValueError(f"Train label range must be [0, 9]; got [{min_tr_lbl}, {max_tr_lbl}]")
+ if min_te_lbl != 0 or max_te_lbl != 9:
+ raise ValueError(f"Test label range must be [0, 9]; got [{min_te_lbl}, {max_te_lbl}]")
+
+ x_train_raw = (train_dataset.data.float() / 255.0).reshape(60000, -1).numpy()
+ x_test_raw = (test_dataset.data.float() / 255.0).reshape(10000, -1).numpy()
+
+ pca = PCA(n_components=32, whiten=True, random_state=42)
+ x_full_tr = torch.tensor(pca.fit_transform(x_train_raw), dtype=torch.float32)
+ x_full_test = torch.tensor(pca.transform(x_test_raw), dtype=torch.float32)
+
+ data_fp = compute_data_fingerprint(x_full_tr, x_full_test, y_train_60000, y_test_10000)
+ pca_provenance = {
+ "n_components": 32,
+ "whiten": True,
+ "random_state": 42,
+ "fit_scope": "official_train_split_60000_only",
+ "train_samples_fit": 60000,
+ "test_samples_transformed": 10000,
+ "explained_variance_ratio_sum": float(np.sum(pca.explained_variance_ratio_)),
+ }
+ return (
+ x_full_tr,
+ y_train_60000,
+ x_full_test,
+ y_test_10000,
+ data_fp,
+ pca_provenance,
+ )
+
+
+def render_trajectory_plot(
+ checkpoint_stats: Dict[int, Dict[str, Any]],
+ subset_comparison: Dict[str, Any],
+ figure_path: Path,
+):
+ """
+ Render a readable two-panel mean +/- SD trajectory plot for training loss and test accuracy,
+ with optional dashed subset-study mean comparison and epoch 80 marker.
+ """
+ figure_path.parent.mkdir(parents=True, exist_ok=True)
+
+ eps = sorted(list(checkpoint_stats.keys()))
+ tr_loss_mean = [checkpoint_stats[ep]["train_loss"]["mean"] for ep in eps]
+ tr_loss_std = [checkpoint_stats[ep]["train_loss"]["std"] for ep in eps]
+ te_acc_mean = [checkpoint_stats[ep]["test_acc"]["mean"] for ep in eps]
+ te_acc_std = [checkpoint_stats[ep]["test_acc"]["std"] for ep in eps]
+
+ fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8), sharex=True)
+
+ # Panel 1: Training Loss
+ ax1.plot(eps, tr_loss_mean, "o-", color="tab:blue", linewidth=2, label="Full MNIST Train Loss (Mean)")
+ ax1.fill_between(
+ eps,
+ np.array(tr_loss_mean) - np.array(tr_loss_std),
+ np.array(tr_loss_mean) + np.array(tr_loss_std),
+ color="tab:blue",
+ alpha=0.2,
+ label="±1 SD",
+ )
+
+ if "matching_epoch_deltas" in subset_comparison:
+ sub_deltas = subset_comparison["matching_epoch_deltas"]
+ sub_eps = sorted([ep for ep in eps if str(ep) in sub_deltas or ep in sub_deltas])
+ if sub_eps:
+ sub_tr_loss = [sub_deltas.get(str(ep), sub_deltas.get(ep, {}))["subset_study_train_loss_mean"] for ep in sub_eps]
+ ax1.plot(sub_eps, sub_tr_loss, "--", color="gray", alpha=0.8, label="Subset Study (2k sample) Train Loss")
+
+ if 80 in eps:
+ ax1.axvline(80, color="red", linestyle=":", label="Epoch 80 Marker")
+
+ ax1.set_ylabel("Training Loss")
+ ax1.set_title("Full MNIST (60,000 Train / 10,000 Test) PSO Trajectory (120 Particles, AM)")
+ ax1.grid(True, linestyle="--", alpha=0.5)
+ ax1.legend(loc="upper right")
+
+ # Panel 2: Test Accuracy
+ ax2.plot(eps, te_acc_mean, "s-", color="tab:green", linewidth=2, label="Full MNIST Test Accuracy (Mean)")
+ ax2.fill_between(
+ eps,
+ np.array(te_acc_mean) - np.array(te_acc_std),
+ np.array(te_acc_mean) + np.array(te_acc_std),
+ color="tab:green",
+ alpha=0.2,
+ label="±1 SD",
+ )
+
+ if "matching_epoch_deltas" in subset_comparison:
+ sub_deltas = subset_comparison["matching_epoch_deltas"]
+ sub_eps = sorted([ep for ep in eps if str(ep) in sub_deltas or ep in sub_deltas])
+ if sub_eps:
+ sub_te_acc = [sub_deltas.get(str(ep), sub_deltas.get(ep, {}))["subset_study_test_acc_mean"] for ep in sub_eps]
+ ax2.plot(sub_eps, sub_te_acc, "--", color="gray", alpha=0.8, label="Subset Study (2k sample) Test Acc")
+
+ if 80 in eps:
+ ax2.axvline(80, color="red", linestyle=":", label="Epoch 80 Marker")
+
+ ax2.set_xlabel("Epoch")
+ ax2.set_ylabel("Test Accuracy")
+ ax2.grid(True, linestyle="--", alpha=0.5)
+ ax2.legend(loc="lower right")
+
+ plt.tight_layout()
+ fig.savefig(figure_path, dpi=300)
+ plt.close(fig)
+
+
+def run_full_mnist_study(
+ baseline_path: Path,
+ subset_study_path: Path,
+ output_json_path: Path,
+ output_csv_path: Path,
+ figure_path: Path,
+ device_str: str = "auto",
+ epochs: int = 240,
+ seeds: List[int] = None,
+) -> bool:
+ if seeds is None:
+ seeds = [71, 72, 73, 74, 75]
+ if not isinstance(epochs, int) or isinstance(epochs, bool) or epochs <= 0:
+ raise ValueError("epochs must be a positive integer")
+ if epochs % 20 != 0:
+ raise ValueError("epochs must be a multiple of 20 so every final checkpoint exists")
+ if not seeds or len(seeds) != len(set(seeds)):
+ raise ValueError("seeds must be a non-empty list of unique integers")
+ if any(isinstance(seed, bool) or not isinstance(seed, int) or seed < 0 for seed in seeds):
+ raise ValueError("every seed must be a non-negative integer")
+
+
+ dev_input = None if device_str == "auto" else device_str
+ device = resolve_execution_device(dev_input)
+ hw_provenance = get_hardware_provenance(device)
+
+ # 1. Validate baseline JSON & load winner config
+ baseline_data, _baseline_records, winner_cfg, _expected_fp = validate_and_load_baseline(
+ baseline_path
+ )
+
+ if baseline_data.get("device") != device.type:
+ raise ValueError(
+ f"Baseline device mismatch: baseline requires {baseline_data.get('device')!r}, got {device.type!r}"
+ )
+ if baseline_data.get("pso_version") != pso_version:
+ raise ValueError(
+ f"PSO version mismatch: baseline requires {baseline_data.get('pso_version')!r}, got {pso_version!r}"
+ )
+ if baseline_data.get("torch_version") != torch.__version__:
+ raise ValueError(
+ f"Torch version mismatch: baseline requires {baseline_data.get('torch_version')!r}, got {torch.__version__!r}"
+ )
+
+ # 2. Prepare Full MNIST PCA Data (60k train / 10k test)
+ (
+ x_full_tr,
+ y_train_60000,
+ x_full_test,
+ y_test_10000,
+ data_fp,
+ pca_provenance,
+ ) = prepare_full_mnist_data()
+
+ opt_kwargs = winner_cfg.to_optimizer_kwargs(quick=False)
+ opt_kwargs["evaluation"] = "full"
+ opt_kwargs.pop("fitness_size", None)
+
+ n_particles = 120
+ target_epochs = epochs
+ batch_size = 60000
+ checkpoint_interval = 20
+
+ ckpt_epochs = [ep for ep in range(checkpoint_interval, target_epochs + 1, checkpoint_interval)]
+ if not ckpt_epochs or ckpt_epochs[-1] != target_epochs:
+ if target_epochs not in ckpt_epochs:
+ ckpt_epochs.append(target_epochs)
+ ckpt_epochs = sorted(list(set(ckpt_epochs)))
+
+ runs: List[Dict[str, Any]] = []
+ flat_csv_rows: List[Dict[str, Any]] = []
+ plugin_meta: Dict[str, Any] | None = None
+
+ # 3. Seed Runs
+ for seed in sorted(seeds):
+ # Warmup Phase (2 epochs full eval)
+ warmup_model = make_mnist_model(seed=seed)
+ warmup_loss = nn.CrossEntropyLoss()
+ warmup_opt = Optimizer(
+ model=warmup_model,
+ loss=warmup_loss,
+ task="multiclass",
+ n_particles=n_particles,
+ seed=seed,
+ device=device,
+ **opt_kwargs,
+ )
+ warmup_opt.fit(
+ x_full_tr,
+ y_train_60000,
+ epochs=2,
+ batch_size=batch_size,
+ renewal="loss",
+ )
+ sync_device(device)
+ del warmup_opt, warmup_model, warmup_loss
+
+ # Timed Continuous Trajectory
+ model = make_mnist_model(seed=seed)
+ model_fp = compute_model_fingerprint(model)
+ loss_inst = nn.CrossEntropyLoss()
+ opt = Optimizer(
+ model=model,
+ loss=loss_inst,
+ task="multiclass",
+ n_particles=n_particles,
+ seed=seed,
+ device=device,
+ **opt_kwargs,
+ )
+ current_plugin_meta = extract_plugin_metadata(opt)
+ if plugin_meta is None:
+ plugin_meta = current_plugin_meta
+ elif current_plugin_meta != plugin_meta:
+ raise RuntimeError("Resolved plugin metadata changed across seeds")
+
+
+ with tempfile.TemporaryDirectory() as temp_dir_str:
+ output_dir = Path(temp_dir_str)
+ sync_device(device)
+ t0 = time.perf_counter()
+ train_loss_final, train_acc_final, train_mse_final = opt.fit(
+ x_full_tr,
+ y_train_60000,
+ epochs=target_epochs,
+ batch_size=batch_size,
+ renewal="loss",
+ output_dir=output_dir,
+ log_format="csv",
+ checkpoint_interval=checkpoint_interval,
+ )
+ sync_device(device)
+ t1 = time.perf_counter()
+ fit_time_sec = t1 - t0
+
+ if not (math.isfinite(train_loss_final) and math.isfinite(train_acc_final) and math.isfinite(train_mse_final)):
+ raise RuntimeError(f"Seed {seed} final metrics non-finite: loss={train_loss_final}, acc={train_acc_final}")
+
+ history_csv_path = output_dir / "history.csv"
+ epoch_history = []
+ if history_csv_path.exists():
+ with open(history_csv_path, "r", encoding="utf-8") as f:
+ reader = csv.DictReader(f)
+ for row in reader:
+ epoch_history.append({
+ "epoch": int(row["epoch"]),
+ "loss": float(row["loss"]),
+ "accuracy": float(row["accuracy"]),
+ "mse": float(row["mse"]),
+ })
+
+ prev_best_loss = float("inf")
+ improvement_count = 0
+ last_improvement_epoch = 1
+ for row in epoch_history:
+ ep_num = row["epoch"]
+ l_val = row["loss"]
+ if l_val < prev_best_loss:
+ improvement_count += 1
+ last_improvement_epoch = ep_num
+ prev_best_loss = l_val
+
+ checkpoints: List[Dict[str, Any]] = []
+ ckpt_dir = output_dir / "checkpoints"
+ for ep in ckpt_epochs:
+ ckpt_path = ckpt_dir / f"epoch-{ep}.pt"
+ if not ckpt_path.exists():
+ raise FileNotFoundError(f"Missing checkpoint file: {ckpt_path}")
+ payload = torch.load(ckpt_path, map_location=device, weights_only=True)
+ ckpt_tr_loss, ckpt_tr_acc, ckpt_tr_mse = payload["score"]
+ if not (math.isfinite(ckpt_tr_loss) and math.isfinite(ckpt_tr_acc) and math.isfinite(ckpt_tr_mse)):
+ raise RuntimeError(f"Seed {seed} epoch {ep} score non-finite: {payload['score']}")
+
+ opt.eval_model.load_state_dict(payload["model_state_dict"])
+ opt._global_best_weights = opt.codec.encode(opt.eval_model)
+ test_loss, test_acc, test_mse = opt.evaluate(x_full_test, y_test_10000)
+
+ if not (math.isfinite(test_loss) and math.isfinite(test_acc) and math.isfinite(test_mse)):
+ raise RuntimeError(f"Seed {seed} epoch {ep} test metrics non-finite: loss={test_loss}, acc={test_acc}")
+
+ ckpt_record = {
+ "epoch": ep,
+ "train_loss": float(ckpt_tr_loss),
+ "train_acc": float(ckpt_tr_acc),
+ "train_mse": float(ckpt_tr_mse),
+ "test_loss": float(test_loss),
+ "test_acc": float(test_acc),
+ "test_mse": float(test_mse),
+ }
+ checkpoints.append(ckpt_record)
+
+ flat_csv_rows.append({
+ "seed": seed,
+ "epoch": ep,
+ "train_loss": float(ckpt_tr_loss),
+ "train_acc": float(ckpt_tr_acc),
+ "train_mse": float(ckpt_tr_mse),
+ "test_loss": float(test_loss),
+ "test_acc": float(test_acc),
+ "test_mse": float(test_mse),
+ "fit_time_sec": round(fit_time_sec, 4),
+ })
+
+ runs.append({
+ "seed": seed,
+ "model_fingerprint": model_fp,
+ "fit_time_sec": round(fit_time_sec, 4),
+ "improvement_count": improvement_count,
+ "last_improvement_epoch": last_improvement_epoch,
+ "checkpoints": checkpoints,
+ "completed": True,
+ "error": None,
+ "plugins": current_plugin_meta,
+ "epoch_history": epoch_history,
+ })
+
+ # 4. Aggregations & Statistics
+ checkpoint_stats: Dict[int, Dict[str, Any]] = {}
+ for ep in ckpt_epochs:
+ ep_train_losses = [next(c["train_loss"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+ ep_train_accs = [next(c["train_acc"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+ ep_train_mses = [next(c["train_mse"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+
+ ep_test_losses = [next(c["test_loss"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+ ep_test_accs = [next(c["test_acc"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+ ep_test_mses = [next(c["test_mse"] for c in r["checkpoints"] if c["epoch"] == ep) for r in runs]
+
+ checkpoint_stats[ep] = {
+ "train_loss": calc_stats(ep_train_losses),
+ "train_acc": calc_stats(ep_train_accs),
+ "train_mse": calc_stats(ep_train_mses),
+ "test_loss": calc_stats(ep_test_losses),
+ "test_acc": calc_stats(ep_test_accs),
+ "test_mse": calc_stats(ep_test_mses),
+ }
+
+ # Endpoint paired deltas (80->240 and 200->240 if available)
+ paired_deltas: Dict[str, Any] = {}
+ paired_endpoint_deltas_by_seed: List[Dict[str, Any]] = []
+
+ has_80 = 80 in checkpoint_stats
+ has_200 = 200 in checkpoint_stats
+ has_240 = 240 in checkpoint_stats
+
+ if has_80 and has_240:
+ deltas_80_to_240_train_rel = []
+ deltas_80_to_240_test_acc = []
+ for r in runs:
+ c80 = next(c for c in r["checkpoints"] if c["epoch"] == 80)
+ c240 = next(c for c in r["checkpoints"] if c["epoch"] == 240)
+ tl80, tl240 = c80["train_loss"], c240["train_loss"]
+ ta80, ta240 = c80["test_acc"], c240["test_acc"]
+
+ rel_red = (tl80 - tl240) / tl80 if tl80 > 0 else 0.0
+ acc_delta = ta240 - ta80
+ deltas_80_to_240_train_rel.append(rel_red)
+ deltas_80_to_240_test_acc.append(acc_delta)
+
+ paired_rec = {
+ "seed": r["seed"],
+ "train_loss_relative_reduction_80_to_240": rel_red,
+ "test_accuracy_delta_80_to_240": acc_delta,
+ }
+ if has_200:
+ c200 = next(c for c in r["checkpoints"] if c["epoch"] == 200)
+ tl200, ta200 = c200["train_loss"], c200["test_acc"]
+ rel_red_200 = (tl200 - tl240) / tl200 if tl200 > 0 else 0.0
+ acc_delta_200 = ta240 - ta200
+ paired_rec["train_loss_relative_reduction_200_to_240"] = rel_red_200
+ paired_rec["test_accuracy_delta_200_to_240"] = acc_delta_200
+ paired_endpoint_deltas_by_seed.append(paired_rec)
+
+ paired_deltas["80_to_240"] = {
+ "train_loss_rel_reduction": calc_stats(deltas_80_to_240_train_rel),
+ "test_acc_delta": calc_stats(deltas_80_to_240_test_acc),
+ }
+
+ if has_200 and has_240:
+ deltas_200_to_240_train_rel = []
+ deltas_200_to_240_test_acc = []
+ deltas_200_to_240_test_acc_abs = []
+ for r in runs:
+ c200 = next(c for c in r["checkpoints"] if c["epoch"] == 200)
+ c240 = next(c for c in r["checkpoints"] if c["epoch"] == 240)
+ tl200, tl240 = c200["train_loss"], c240["train_loss"]
+ ta200, ta240 = c200["test_acc"], c240["test_acc"]
+ rel_red_200 = (tl200 - tl240) / tl200 if tl200 > 0 else 0.0
+ acc_delta_200 = ta240 - ta200
+ acc_abs_200 = abs(ta240 - ta200)
+ deltas_200_to_240_train_rel.append(rel_red_200)
+ deltas_200_to_240_test_acc.append(acc_delta_200)
+ deltas_200_to_240_test_acc_abs.append(acc_abs_200)
+
+ paired_deltas["200_to_240"] = {
+ "train_loss_rel_reduction": calc_stats(deltas_200_to_240_train_rel),
+ "test_acc_delta": calc_stats(deltas_200_to_240_test_acc),
+ "test_acc_abs_change": calc_stats(deltas_200_to_240_test_acc_abs),
+ }
+
+ # Predeclared Diagnostics
+ diagnostics = {}
+ if has_80 and has_240:
+ mean_tl80 = checkpoint_stats[80]["train_loss"]["mean"]
+ mean_tl240 = checkpoint_stats[240]["train_loss"]["mean"]
+ mean_ta80 = checkpoint_stats[80]["test_acc"]["mean"]
+ mean_ta240 = checkpoint_stats[240]["test_acc"]["mean"]
+
+ post80_train_improvement_pct = (mean_tl80 - mean_tl240) / mean_tl80 if mean_tl80 > 0 else 0.0
+ epoch240_test_gain = mean_ta240 - mean_ta80
+
+ diagnostics["post80_train_improvement_pct"] = round(post80_train_improvement_pct, 6)
+ diagnostics["post80_train_improvement_passed"] = bool(post80_train_improvement_pct >= 0.01)
+
+ diagnostics["epoch240_test_gain"] = round(epoch240_test_gain, 6)
+ diagnostics["epoch240_test_gain_passed"] = bool(epoch240_test_gain >= 0.01)
+
+ if has_200:
+ mean_tl200 = checkpoint_stats[200]["train_loss"]["mean"]
+ mean_ta200 = checkpoint_stats[200]["test_acc"]["mean"]
+ late_rel_red = (mean_tl200 - mean_tl240) / mean_tl200 if mean_tl200 > 0 else 0.0
+ late_acc_abs = abs(mean_ta240 - mean_ta200)
+
+ is_late_plateau = bool(late_rel_red < 0.01 and late_acc_abs < 0.005)
+ diagnostics["late_plateau_200_240"] = is_late_plateau
+ diagnostics["late_plateau_train_loss_rel_reduction_200_240"] = round(late_rel_red, 6)
+ diagnostics["late_plateau_test_acc_abs_change_200_240"] = round(late_acc_abs, 6)
+
+ # 5. Descriptive Comparison vs Subset Study
+ subset_comparison: Dict[str, Any] = {}
+ if subset_study_path.exists():
+ try:
+ with open(subset_study_path, "r", encoding="utf-8") as f:
+ sub_json_data = json.load(f)
+ sub_ckpt_stats = sub_json_data.get("summary", {}).get("checkpoint_stats", {})
+ matching_stats = {}
+ for ep in ckpt_epochs:
+ ep_str = str(ep)
+ if ep_str in sub_ckpt_stats:
+ sub_e = sub_ckpt_stats[ep_str]
+ full_tr_l = checkpoint_stats[ep]["train_loss"]["mean"]
+ sub_tr_l = sub_e["train_loss"]["mean"]
+ full_te_a = checkpoint_stats[ep]["test_acc"]["mean"]
+ sub_te_a = sub_e["test_acc"]["mean"]
+
+ matching_stats[ep_str] = {
+ "full_mnist_train_loss_mean": full_tr_l,
+ "subset_study_train_loss_mean": sub_tr_l,
+ "train_loss_delta_full_minus_subset": round(full_tr_l - sub_tr_l, 6),
+ "full_mnist_test_acc_mean": full_te_a,
+ "subset_study_test_acc_mean": sub_te_a,
+ "test_acc_delta_full_minus_subset": round(full_te_a - sub_te_a, 6),
+ }
+
+ subset_comparison = {
+ "subset_study_path": str(subset_study_path),
+ "disclaimer": (
+ "The full and subset studies optimize different training objectives and the evaluation "
+ "plugin changes RNG consumption (all 60,000 train samples versus a fixed 2,000-sample "
+ "fitness subset). Matching-seed and matching-epoch comparisons are descriptive, not an "
+ "exact paired causal isolation."
+ ),
+ "matching_epoch_deltas": matching_stats,
+ }
+ except Exception as err:
+ subset_comparison = {"error": f"Failed to parse subset study JSON: {err}"}
+
+ # 6. Save Artifacts
+ # JSON output
+ out_dict = {
+ "full_mnist_protocol_version": FULL_MNIST_PROTOCOL_VERSION,
+ "pso_version": pso_version,
+ "torch_version": torch.__version__,
+ "hardware": hw_provenance,
+ "device": device.type,
+ "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+ "baseline_path": str(baseline_path),
+ "subset_study_path": str(subset_study_path),
+ "sample_counts": {
+ "train_samples": 60000,
+ "test_samples": 10000,
+ },
+ "pca_provenance": pca_provenance,
+ "data_fingerprint": data_fp,
+ "fitness_evaluation_contract": {
+ "selector": "full",
+ "fitness_size": None,
+ "train_samples_per_particle_per_epoch": 60000,
+ "particle_evaluations": n_particles * target_epochs * len(seeds),
+ "particle_sample_evaluations": (
+ n_particles * target_epochs * len(seeds) * 60000
+ ),
+ "test_samples_per_checkpoint": 10000,
+ },
+ "candidate_label": winner_cfg.candidate_label,
+ "config": {
+ **opt_kwargs,
+ "n_particles": n_particles,
+ "epochs": target_epochs,
+ "batch_size": batch_size,
+ "renewal": "loss",
+ "checkpoint_interval": checkpoint_interval,
+ },
+ "plugins": plugin_meta,
+ "timing_scope": "fit_only_after_full-evaluation_two-epoch_warmup",
+ "diagnostics": diagnostics,
+ "descriptive_subset_comparison": subset_comparison,
+ "summary": {
+ "epochs": ckpt_epochs,
+ "checkpoint_stats": {str(k): v for k, v in checkpoint_stats.items()},
+ "paired_deltas": paired_deltas,
+ "paired_endpoint_deltas_by_seed": paired_endpoint_deltas_by_seed,
+ },
+ "runs": runs,
+ "completed": True,
+ "valid": True,
+ "error": None,
+ }
+ save_json_atomic(out_dict, output_json_path)
+
+ # CSV output
+ output_csv_path.parent.mkdir(parents=True, exist_ok=True)
+ fieldnames = [
+ "seed",
+ "epoch",
+ "train_loss",
+ "train_acc",
+ "train_mse",
+ "test_loss",
+ "test_acc",
+ "test_mse",
+ "fit_time_sec",
+ ]
+ with open(output_csv_path, "w", encoding="utf-8", newline="") as f:
+ writer = csv.DictWriter(f, fieldnames=fieldnames)
+ writer.writeheader()
+ for r in flat_csv_rows:
+ writer.writerow(r)
+
+ # Plot output
+ render_trajectory_plot(checkpoint_stats, subset_comparison, figure_path)
+
+ return True
+
+
+def main():
+ parser = argparse.ArgumentParser(
+ description="Full-MNIST 60k/10k Particle Swarm Optimization Trajectory Analysis"
+ )
+ parser.add_argument(
+ "--baseline-json",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_tuning.json"),
+ help="Path to baseline tuning JSON (default: benchmark_results/pso_v4_tuning.json)",
+ )
+ parser.add_argument(
+ "--subset-study-json",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_epoch_convergence.json"),
+ help="Path to subset epoch convergence JSON (default: benchmark_results/pso_v4_epoch_convergence.json)",
+ )
+ parser.add_argument(
+ "--output-json",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_full_mnist.json"),
+ help="Path to output JSON (default: benchmark_results/pso_v4_full_mnist.json)",
+ )
+ parser.add_argument(
+ "--output-csv",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_full_mnist.csv"),
+ help="Path to output CSV (default: benchmark_results/pso_v4_full_mnist.csv)",
+ )
+ parser.add_argument(
+ "--figure",
+ type=Path,
+ default=Path("history_plt/pso_v4_full_mnist.png"),
+ help="Path to output plot figure PNG (default: history_plt/pso_v4_full_mnist.png)",
+ )
+ parser.add_argument(
+ "--device",
+ type=str,
+ default="auto",
+ help="Execution device: auto, mps, cpu, cuda (default: auto)",
+ )
+ parser.add_argument(
+ "--epochs",
+ type=int,
+ default=240,
+ help="Number of PSO training epochs (default: 240)",
+ )
+ parser.add_argument(
+ "--seeds",
+ type=str,
+ default="71,72,73,74,75",
+ help="Comma-separated random seeds (default: 71,72,73,74,75)",
+ )
+
+ args = parser.parse_args()
+ seed_list = [int(s.strip()) for s in args.seeds.split(",") if s.strip()]
+
+ run_full_mnist_study(
+ baseline_path=args.baseline_json,
+ subset_study_path=args.subset_study_json,
+ output_json_path=args.output_json,
+ output_csv_path=args.output_csv,
+ figure_path=args.figure,
+ device_str=args.device,
+ epochs=args.epochs,
+ seeds=seed_list,
+ )
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/heavy_pso_autoresearch.py b/test/heavy_pso_autoresearch.py
new file mode 100644
index 0000000..d0db2c8
--- /dev/null
+++ b/test/heavy_pso_autoresearch.py
@@ -0,0 +1,1321 @@
+"""
+Equalized Signed-Hash Subspace Experiment Runner for Heavy Task Autoresearch.
+
+Protocol Version: HEAVY-PSO-AUTORESEARCH 1.0.0
+
+Runs matched equalized signed-hash subspace PSO experiments across four candidate
+latent ratios (0.5, 0.25, 0.125, 0.03125) and four heavy workloads:
+ - mnist_compact (Base geometry: G6)
+ - mnist_wide (Base geometry: G5)
+ - fashion_compact (Base geometry: G6)
+ - fashion_wide (Base geometry: G5)
+
+Configurations are matched to confirmation runs (12 particles, 80 epochs, fixed 10k, seeds 101-103).
+Official test splits are NEVER loaded or evaluated (official_test_evaluations = 0).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import hashlib
+import math
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+# Ensure test directory and repo root are in Python path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+from benchmark_suite import (
+ calc_stats,
+ compute_model_fingerprint,
+ get_hardware_provenance,
+ resolve_execution_device,
+ save_json_atomic,
+)
+from deep_pso_v6 import (
+ V6GeometryConfig,
+ V6LatentTransform,
+ compute_equalized_subspace_radius,
+ get_v6_geometry_table,
+ run_v6_pso,
+ artifact_safe_run,
+)
+from heavy_task_feasibility import (
+ WORKLOADS,
+ create_model,
+ prepare_heavy_task_data,
+)
+
+# Protocol Constant
+AUTORESEARCH_PROTOCOL_VERSION = "HEAVY-PSO-AUTORESEARCH 1.0.0"
+
+# Defaults
+DEFAULT_RATIOS = (1.0, 0.5, 0.25, 0.125, 0.03125)
+DEFAULT_PARTICLES = 12
+DEFAULT_EPOCHS = 80
+DEFAULT_SUBSET_SIZE = 10000
+DEFAULT_SEEDS = (101, 102, 103)
+DEFAULT_SPLIT_SEED = 20260902
+DEFAULT_GEOMETRY_POLICY = "recovered"
+DEFAULT_PROJECTION_SCOPE = "global"
+PROJECTION_SCOPES = ("global", "tensor_local", "balanced_global", "two_hash_global", "largest_tensor_hash", "largest_tensor_row_hash", "adjacent_pair", "adjacent_difference")
+DEFAULT_PROJECTION_SEED_MODE = "coupled"
+PROJECTION_SEED_MODES = ("coupled", "fixed", "explicit")
+DEFAULT_GEOMETRY_MULTIPLIER = 1.0
+
+
+def validate_geometry_multiplier(geometry_multiplier: Any) -> None:
+ """
+ Validates that geometry_multiplier is a finite positive float (> 0).
+ Raises ValueError on non-numeric, non-finite, or non-positive values.
+ """
+ if (
+ not isinstance(geometry_multiplier, (int, float))
+ or isinstance(geometry_multiplier, bool)
+ or not math.isfinite(geometry_multiplier)
+ or geometry_multiplier <= 0
+ ):
+ raise ValueError(
+ f"geometry_multiplier must be a finite positive float (> 0), got {geometry_multiplier!r}"
+ )
+
+def parse_projection_seed_arg(val: Any) -> Optional[Union[int, Dict[str, int]]]:
+ """
+ Parses projection_seed parameter or CLI arg into None, int, or Dict[str, int].
+ Accepts integer values, integer strings, JSON dict strings, or comma/colon key-value strings.
+ """
+ if val is None or val == "" or val == "None":
+ return None
+ if isinstance(val, (int, dict)):
+ return val
+ if isinstance(val, str):
+ val_str = val.strip()
+ if not val_str:
+ return None
+ try:
+ return int(val_str)
+ except ValueError:
+ pass
+ if val_str.startswith("{") and val_str.endswith("}"):
+ try:
+ parsed = json.loads(val_str)
+ if isinstance(parsed, dict):
+ return {str(k): int(v) for k, v in parsed.items()}
+ except (json.JSONDecodeError, ValueError, TypeError) as exc:
+ raise ValueError(f"Failed to parse projection_seed JSON dict string '{val}': {exc}")
+ if ":" in val_str or "=" in val_str:
+ res = {}
+ for item in val_str.replace(";", ",").split(","):
+ item = item.strip()
+ if not item:
+ continue
+ if ":" in item:
+ k, v = item.split(":", 1)
+ elif "=" in item:
+ k, v = item.split("=", 1)
+ else:
+ raise ValueError(f"Invalid key-value projection_seed string item '{item}'")
+ res[k.strip()] = int(v.strip())
+ if res:
+ return res
+ raise ValueError(f"Cannot parse projection_seed value: {val!r}")
+
+
+def validate_projection_seed_config(
+ projection_seed_mode: str,
+ projection_seed: Optional[Union[int, Dict[str, int]]],
+) -> None:
+ """
+ Validates projection_seed_mode and projection_seed invariants.
+ Raises ValueError on invalid modes, missing explicit seeds, out-of-range explicit seeds,
+ or seeds supplied to non-explicit modes.
+ """
+ if projection_seed_mode not in PROJECTION_SEED_MODES:
+ raise ValueError(
+ f"Invalid projection_seed_mode '{projection_seed_mode}'. Must be one of {list(PROJECTION_SEED_MODES)}"
+ )
+ if projection_seed_mode == "explicit":
+ if projection_seed is None:
+ raise ValueError(
+ "projection_seed must be provided when projection_seed_mode is 'explicit'"
+ )
+ if isinstance(projection_seed, int) and not isinstance(projection_seed, bool):
+ if not (0 <= projection_seed < (2**31 - 1)):
+ raise ValueError(
+ f"projection_seed must be a non-negative integer < 2**31-1, got {projection_seed!r}"
+ )
+ elif isinstance(projection_seed, dict):
+ if not projection_seed:
+ raise ValueError("projection_seed dictionary cannot be empty")
+ expected_keys = set(WORKLOADS.keys())
+ provided_keys = set(projection_seed.keys())
+ missing_keys = expected_keys - provided_keys
+ unknown_keys = provided_keys - expected_keys
+ if missing_keys or unknown_keys:
+ details = []
+ if missing_keys:
+ details.append(f"missing required workload key(s) {sorted(missing_keys)}")
+ if unknown_keys:
+ details.append(f"Unknown workload_id key(s) {sorted(unknown_keys)}")
+ raise ValueError(
+ f"projection_seed dictionary must contain exactly WORKLOADS keys ({sorted(expected_keys)}); "
+ + ", ".join(details)
+ )
+ for k, v in projection_seed.items():
+ if (
+ not isinstance(v, int)
+ or isinstance(v, bool)
+ or not (0 <= v < (2**31 - 1))
+ ):
+ raise ValueError(
+ f"projection_seed for workload '{k}' must be a non-negative integer < 2**31-1, got {v!r}"
+ )
+ else:
+ raise ValueError(
+ f"projection_seed must be a non-negative integer < 2**31-1 or a "
+ f"Dict[str, int], got {projection_seed!r}"
+ )
+ else:
+ if projection_seed is not None:
+ raise ValueError(
+ f"projection_seed can only be provided when projection_seed_mode is 'explicit', got mode='{projection_seed_mode}' and projection_seed={projection_seed!r}"
+ )
+def parse_projection_scope_arg(val: Any) -> Union[str, Dict[str, str]]:
+ """
+ Parses projection_scope parameter or CLI arg into a string or Dict[str, str].
+ Accepts valid scope strings, JSON dict strings, or comma/colon key-value strings.
+ """
+ if val is None or val == "":
+ return DEFAULT_PROJECTION_SCOPE
+ if isinstance(val, dict):
+ return {str(k): str(v) for k, v in val.items()}
+ if isinstance(val, str):
+ val_str = val.strip()
+ if not val_str:
+ return DEFAULT_PROJECTION_SCOPE
+ if val_str in PROJECTION_SCOPES:
+ return val_str
+ if val_str.startswith("{") and val_str.endswith("}"):
+ try:
+ parsed = json.loads(val_str)
+ if isinstance(parsed, dict):
+ return {str(k): str(v) for k, v in parsed.items()}
+ except Exception as exc:
+ raise ValueError(f"Failed to parse projection_scope JSON dict string '{val}': {exc}")
+ if ":" in val_str or "=" in val_str:
+ res = {}
+ for item in val_str.replace(";", ",").split(","):
+ item = item.strip()
+ if not item:
+ continue
+ if ":" in item:
+ k, v = item.split(":", 1)
+ elif "=" in item:
+ k, v = item.split("=", 1)
+ else:
+ raise ValueError(f"Invalid key-value projection_scope string item '{item}'")
+ res[k.strip()] = v.strip()
+ if res:
+ return res
+ return val_str
+ raise ValueError(f"Cannot parse projection_scope value: {val!r}")
+
+
+def validate_projection_scope_config(projection_scope: Any) -> None:
+ """
+ Validates projection_scope string or dictionary config.
+ Raises ValueError if string is not in PROJECTION_SCOPES, or if dict
+ keys do not match WORKLOADS exactly or values are not in PROJECTION_SCOPES.
+ """
+ if isinstance(projection_scope, str):
+ if projection_scope not in PROJECTION_SCOPES:
+ raise ValueError(
+ f"Invalid projection_scope '{projection_scope}'. Must be one of {list(PROJECTION_SCOPES)}"
+ )
+ elif isinstance(projection_scope, dict):
+ if not projection_scope:
+ raise ValueError("projection_scope dictionary cannot be empty")
+ if set(projection_scope.keys()) != set(WORKLOADS.keys()):
+ missing = sorted(list(set(WORKLOADS.keys()) - set(projection_scope.keys())))
+ extra = sorted(list(set(projection_scope.keys()) - set(WORKLOADS.keys())))
+ details = []
+ if missing:
+ details.append(f"missing keys {missing}")
+ if extra:
+ details.append(f"unknown keys {extra}")
+ raise ValueError(
+ f"projection_scope dictionary must contain exact workload keys {sorted(list(WORKLOADS.keys()))}, got {', '.join(details)}"
+ )
+ for k, v in projection_scope.items():
+ if v not in PROJECTION_SCOPES:
+ raise ValueError(
+ f"Invalid projection_scope '{v}' for workload '{k}'. Must be one of {list(PROJECTION_SCOPES)}"
+ )
+ else:
+ raise ValueError(
+ f"projection_scope must be a string or Dict[str, str], got {projection_scope!r}"
+ )
+
+
+def get_effective_projection_scope(
+ projection_scope: Union[str, Dict[str, str]],
+ workload_id: str,
+) -> str:
+ """
+ Returns the effective projection scope string for a given workload.
+ """
+ if isinstance(projection_scope, dict):
+ if workload_id not in projection_scope:
+ raise ValueError(f"Missing workload_id '{workload_id}' in projection_scope dict")
+ return str(projection_scope[workload_id])
+ return str(projection_scope)
+
+
+def allocate_tensor_latent_dims(
+ param_numels: Sequence[int],
+ aggregate_latent_dim: int,
+) -> List[int]:
+ """
+ Allocates aggregate_latent_dim across parameter tensors deterministically,
+ proportionally to tensor numel, with at least one coordinate per tensor,
+ no tensor exceeding numel, and exact sum aggregate_latent_dim.
+ """
+ total_dim = sum(param_numels)
+ if not (0 < aggregate_latent_dim <= total_dim):
+ raise ValueError(
+ f"aggregate_latent_dim must be in (0, {total_dim}], got {aggregate_latent_dim}"
+ )
+ num_tensors = len(param_numels)
+ if aggregate_latent_dim < num_tensors:
+ raise ValueError(
+ f"aggregate_latent_dim ({aggregate_latent_dim}) must be at least number of parameter tensors ({num_tensors})"
+ )
+
+ if aggregate_latent_dim == total_dim:
+ return list(param_numels)
+
+ quotas = [aggregate_latent_dim * n / total_dim for n in param_numels]
+ allocs = [max(1, min(n, int(math.floor(q)))) for n, q in zip(param_numels, quotas)]
+ current_sum = sum(allocs)
+
+ if current_sum < aggregate_latent_dim:
+ deficit = aggregate_latent_dim - current_sum
+ candidates = [i for i in range(num_tensors) if allocs[i] < param_numels[i]]
+ candidates.sort(
+ key=lambda i: (quotas[i] - math.floor(quotas[i]), param_numels[i], -i),
+ reverse=True,
+ )
+ for i in candidates[:deficit]:
+ allocs[i] += 1
+ elif current_sum > aggregate_latent_dim:
+ surplus = current_sum - aggregate_latent_dim
+ candidates = [i for i in range(num_tensors) if allocs[i] > 1]
+ candidates.sort(
+ key=lambda i: (quotas[i] - math.floor(quotas[i]), param_numels[i], -i),
+ reverse=False,
+ )
+ for i in candidates[:surplus]:
+ allocs[i] -= 1
+
+ assert sum(allocs) == aggregate_latent_dim, (
+ f"Allocation sum {sum(allocs)} does not match aggregate_latent_dim {aggregate_latent_dim}"
+ )
+ assert all(1 <= a <= n for a, n in zip(allocs, param_numels)), (
+ f"Allocation bounds violated: {allocs} vs numels {param_numels}"
+ )
+ return allocs
+
+
+class TensorLocalLatentTransform(V6LatentTransform):
+ """
+ Subclass of V6LatentTransform that isolates signed-hash coordinates within each model
+ parameter tensor, mapping each tensor's parameters only to its assigned contiguous latent slice.
+ """
+
+ def __init__(
+ self,
+ base_model: nn.Module,
+ geom_config: V6GeometryConfig,
+ device: torch.device,
+ ):
+ super().__init__(base_model, geom_config, device)
+ if not self.is_full:
+ self.tensor_latent_dims = allocate_tensor_latent_dims(
+ self.param_numels, self.latent_dim
+ )
+ k_indices = np.zeros(self.total_dim, dtype=np.int64)
+ h2_signs = np.zeros(self.total_dim, dtype=np.float32)
+ seed_offset = (
+ geom_config.projection_seed
+ if geom_config.projection_seed is not None
+ else 0
+ )
+
+ j_offset = 0
+ l_offset = 0
+ for numel, d_m in zip(self.param_numels, self.tensor_latent_dims):
+ j_local = np.arange(numel, dtype=np.int64)
+ j_global = j_offset + j_local
+ h1 = ((j_global + 1 + seed_offset) * 2654435761) % (2**32)
+ k_local = h1 % d_m
+ k_indices[j_global] = l_offset + k_local
+ h2 = ((j_global + 1 + seed_offset) * 1597334677) % (2**32)
+ h2_signs[j_global] = np.where((h2 % 2) == 0, 1.0, -1.0)
+ j_offset += numel
+ l_offset += d_m
+
+ bin_counts = np.bincount(k_indices, minlength=self.latent_dim)
+ count_per_j = bin_counts[k_indices]
+ scale_per_j = 1.0 / np.sqrt(np.maximum(count_per_j, 1))
+ combined_weights = h2_signs * scale_per_j
+
+ self.k_indices = torch.tensor(k_indices, dtype=torch.long, device=device)
+ self.weights = torch.tensor(combined_weights, dtype=torch.float32, device=device)
+ else:
+ self.tensor_latent_dims = list(self.param_numels)
+
+class BalancedGlobalLatentTransform(V6LatentTransform):
+ """
+ Subclass of V6LatentTransform that enforces balanced parameter occupancy
+ across global latent coordinate buckets using a deterministic permutation and sign assignment.
+ """
+
+ def __init__(
+ self,
+ base_model: nn.Module,
+ geom_config: V6GeometryConfig,
+ device: torch.device,
+ ):
+ super().__init__(base_model, geom_config, device)
+ if not self.is_full:
+ seed_offset = (
+ geom_config.projection_seed
+ if geom_config.projection_seed is not None
+ else 0
+ )
+ rng = np.random.RandomState(seed_offset)
+ perm = rng.permutation(self.total_dim)
+ k_indices = np.zeros(self.total_dim, dtype=np.int64)
+ k_indices[perm] = np.arange(self.total_dim, dtype=np.int64) % self.latent_dim
+ h2_signs = rng.choice(np.array([1.0, -1.0], dtype=np.float32), size=self.total_dim)
+
+ bin_counts = np.bincount(k_indices, minlength=self.latent_dim)
+ count_per_j = bin_counts[k_indices]
+ scale_per_j = 1.0 / np.sqrt(np.maximum(count_per_j, 1))
+ combined_weights = h2_signs * scale_per_j
+
+ self.k_indices = torch.tensor(k_indices, dtype=torch.long, device=device)
+ self.weights = torch.tensor(combined_weights, dtype=torch.float32, device=device)
+
+
+class TwoHashGlobalLatentTransform(V6LatentTransform):
+ """
+ Subclass of V6LatentTransform that maps each parameter to two distinct global latent
+ coordinate buckets using independent deterministic signed-hash mappings, normalized by
+ per-bucket 1/sqrt(count) weights and decoded as (term1 + term2)/sqrt(2).
+ """
+
+ def __init__(
+ self,
+ base_model: nn.Module,
+ geom_config: V6GeometryConfig,
+ device: torch.device,
+ ):
+ super().__init__(base_model, geom_config, device)
+ if not self.is_full:
+ j_indices = np.arange(self.total_dim, dtype=np.int64)
+ seed_offset = (
+ geom_config.projection_seed
+ if geom_config.projection_seed is not None
+ else 0
+ )
+
+ # Hash Map 1 (Primary signed hash projection)
+ h1_1 = ((j_indices + 1 + seed_offset) * 2654435761) % (2**32)
+ k1_indices = h1_1 % self.latent_dim
+ h1_2 = ((j_indices + 1 + seed_offset) * 1597334677) % (2**32)
+ signs1 = np.where((h1_2 % 2) == 0, 1.0, -1.0)
+
+ bin_counts1 = np.bincount(k1_indices, minlength=self.latent_dim)
+ count_per_j1 = bin_counts1[k1_indices]
+ scale_per_j1 = 1.0 / np.sqrt(np.maximum(count_per_j1, 1))
+ combined_weights1 = signs1 * scale_per_j1
+
+ # Hash Map 2 (Secondary independent signed hash projection)
+ h2_1 = ((j_indices + 1 + seed_offset) * 2246822519) % (2**32)
+ if self.latent_dim > 1:
+ offset = 1 + (h2_1 % (self.latent_dim - 1))
+ k2_indices = (k1_indices + offset) % self.latent_dim
+ else:
+ k2_indices = np.zeros(self.total_dim, dtype=np.int64)
+
+ h2_2 = ((j_indices + 1 + seed_offset) * 3266489917) % (2**32)
+ signs2 = np.where(((h2_2 >> 16) % 2) == 0, 1.0, -1.0)
+
+ bin_counts2 = np.bincount(k2_indices, minlength=self.latent_dim)
+ count_per_j2 = bin_counts2[k2_indices]
+ scale_per_j2 = 1.0 / np.sqrt(np.maximum(count_per_j2, 1))
+ combined_weights2 = signs2 * scale_per_j2
+
+ self.k1_indices = torch.tensor(k1_indices, dtype=torch.long, device=device)
+ self.weights1 = torch.tensor(combined_weights1, dtype=torch.float32, device=device)
+ self.k2_indices = torch.tensor(k2_indices, dtype=torch.long, device=device)
+ self.weights2 = torch.tensor(combined_weights2, dtype=torch.float32, device=device)
+
+ # Backward compatibility aliases
+ self.k_indices = self.k1_indices
+ self.weights = self.weights1
+
+ def decode(self, Z: torch.Tensor) -> torch.Tensor:
+ """
+ Transforms latent batch Z (N, d) into full parameter batch (N, D).
+ When not full, term1 = Z[:, k1] * weights1, term2 = Z[:, k2] * weights2,
+ delta = (term1 + term2) / sqrt(2).
+ theta = base_vec + scale_vec * delta
+ """
+ if self.is_full:
+ delta = Z
+ else:
+ term1 = Z[:, self.k1_indices] * self.weights1
+ term2 = Z[:, self.k2_indices] * self.weights2
+ delta = (term1 + term2) / math.sqrt(2.0)
+ return self.base_vec + self.scale_vec * delta
+
+
+class LargestTensorHashLatentTransform(V6LatentTransform):
+ """
+ Subclass of V6LatentTransform that isolates the single largest parameter tensor by numel
+ (with stable first-index tie break) for signed-hash projection, while assigning every parameter
+ in all other tensors a unique direct latent coordinate with weight 1.0.
+ """
+
+ def __init__(
+ self,
+ base_model: nn.Module,
+ geom_config: V6GeometryConfig,
+ device: torch.device,
+ ):
+ super().__init__(base_model, geom_config, device)
+ if not self.is_full:
+ largest_idx = int(np.argmax(self.param_numels))
+ protected_dim = sum(
+ numel for i, numel in enumerate(self.param_numels) if i != largest_idx
+ )
+ residual_dim = self.latent_dim - protected_dim
+ if residual_dim < 1:
+ raise ValueError(
+ f"latent_dim ({self.latent_dim}) must be greater than protected non-largest parameter dimension ({protected_dim}) "
+ f"to provide at least 1 residual latent coordinate for the largest tensor (index {largest_idx}, numel {self.param_numels[largest_idx]})"
+ )
+
+ k_indices = np.zeros(self.total_dim, dtype=np.int64)
+ weights = np.zeros(self.total_dim, dtype=np.float32)
+ seed_offset = (
+ geom_config.projection_seed
+ if geom_config.projection_seed is not None
+ else 0
+ )
+
+ j_offset = 0
+ direct_coord = 0
+ for i, numel in enumerate(self.param_numels):
+ j_indices_tensor = np.arange(j_offset, j_offset + numel, dtype=np.int64)
+ if i != largest_idx:
+ k_indices[j_indices_tensor] = direct_coord + np.arange(numel, dtype=np.int64)
+ weights[j_indices_tensor] = 1.0
+ direct_coord += numel
+ else:
+ h1 = ((j_indices_tensor + 1 + seed_offset) * 2654435761) % (2**32)
+ k_rel = h1 % residual_dim
+ k_indices[j_indices_tensor] = protected_dim + k_rel
+ h2 = ((j_indices_tensor + 1 + seed_offset) * 1597334677) % (2**32)
+ h2_signs = np.where((h2 % 2) == 0, 1.0, -1.0)
+ weights[j_indices_tensor] = h2_signs
+ j_offset += numel
+
+ bin_counts = np.bincount(k_indices, minlength=self.latent_dim)
+ count_per_j = bin_counts[k_indices]
+ scale_per_j = 1.0 / np.sqrt(np.maximum(count_per_j, 1))
+ combined_weights = weights * scale_per_j
+
+ self.k_indices = torch.tensor(k_indices, dtype=torch.long, device=device)
+ self.weights = torch.tensor(combined_weights, dtype=torch.float32, device=device)
+
+
+class LargestTensorRowHashLatentTransform(V6LatentTransform):
+ """
+ Subclass of V6LatentTransform that isolates the single largest parameter tensor by numel
+ (with stable first-index tie break) for row-partitioned signed-hash projection across its first dimension
+ (rows), while assigning every parameter in all other tensors a unique direct latent coordinate with weight 1.0.
+ """
+
+ def __init__(
+ self,
+ base_model: nn.Module,
+ geom_config: V6GeometryConfig,
+ device: torch.device,
+ ):
+ super().__init__(base_model, geom_config, device)
+ largest_idx = int(np.argmax(self.param_numels))
+ shape = self.param_shapes[largest_idx]
+ num_rows = shape[0] if len(shape) >= 2 else 1
+ largest_numel = self.param_numels[largest_idx]
+ if len(shape) >= 2:
+ elements_per_row = largest_numel // num_rows
+ row_numels = [elements_per_row] * num_rows
+ else:
+ row_numels = [largest_numel]
+
+ if not self.is_full:
+ protected_dim = sum(
+ numel for i, numel in enumerate(self.param_numels) if i != largest_idx
+ )
+ residual_dim = self.latent_dim - protected_dim
+ if residual_dim < num_rows:
+ raise ValueError(
+ f"latent_dim ({self.latent_dim}) must be at least protected dimension ({protected_dim}) "
+ f"+ number of rows ({num_rows}) for largest tensor row hashing, got residual_dim {residual_dim}"
+ )
+
+ row_latent_dims = allocate_tensor_latent_dims(row_numels, residual_dim)
+
+ k_indices = np.zeros(self.total_dim, dtype=np.int64)
+ weights = np.zeros(self.total_dim, dtype=np.float32)
+ seed_offset = (
+ geom_config.projection_seed
+ if geom_config.projection_seed is not None
+ else 0
+ )
+
+ j_offset = 0
+ direct_coord = 0
+ for i, numel in enumerate(self.param_numels):
+ if i != largest_idx:
+ j_indices_tensor = np.arange(j_offset, j_offset + numel, dtype=np.int64)
+ k_indices[j_indices_tensor] = direct_coord + np.arange(numel, dtype=np.int64)
+ weights[j_indices_tensor] = 1.0
+ direct_coord += numel
+ j_offset += numel
+ else:
+ row_slice_start = protected_dim
+ for r, (r_numel, r_dim) in enumerate(zip(row_numels, row_latent_dims)):
+ j_indices_row = np.arange(j_offset, j_offset + r_numel, dtype=np.int64)
+ h1 = ((j_indices_row + 1 + seed_offset) * 2654435761) % (2**32)
+ k_rel = h1 % r_dim
+ k_indices[j_indices_row] = row_slice_start + k_rel
+ h2 = ((j_indices_row + 1 + seed_offset) * 1597334677) % (2**32)
+ h2_signs = np.where((h2 % 2) == 0, 1.0, -1.0)
+ weights[j_indices_row] = h2_signs
+ j_offset += r_numel
+ row_slice_start += r_dim
+
+ bin_counts = np.bincount(k_indices, minlength=self.latent_dim)
+ count_per_j = bin_counts[k_indices]
+ scale_per_j = 1.0 / np.sqrt(np.maximum(count_per_j, 1))
+ combined_weights = weights * scale_per_j
+
+ self.k_indices = torch.tensor(k_indices, dtype=torch.long, device=device)
+ self.weights = torch.tensor(combined_weights, dtype=torch.float32, device=device)
+ self.row_latent_dims = row_latent_dims
+ else:
+ self.row_latent_dims = row_numels
+
+class AdjacentPairLatentTransform(V6LatentTransform):
+ """
+ Subclass of V6LatentTransform that maps each parameter tensor independently
+ by assigning consecutive pairs of parameters to one unique latent coordinate with weights 1/sqrt(2),
+ and a final unpaired parameter (if any) to weight 1.0, concatenating tensor coordinate ranges without sharing.
+ """
+
+ def __init__(
+ self,
+ base_model: nn.Module,
+ geom_config: V6GeometryConfig,
+ device: torch.device,
+ ):
+ super().__init__(base_model, geom_config, device)
+ if not self.is_full:
+ required_dim = sum(math.ceil(n / 2) for n in self.param_numels)
+ if self.latent_dim != required_dim:
+ raise ValueError(
+ f"AdjacentPairLatentTransform requires latent_dim == sum(ceil(numel_i/2)) = {required_dim}, got {self.latent_dim}"
+ )
+ k_indices = np.zeros(self.total_dim, dtype=np.int64)
+ weights = np.zeros(self.total_dim, dtype=np.float32)
+ inv_sqrt2 = 1.0 / math.sqrt(2.0)
+
+ j_offset = 0
+ l_offset = 0
+ self.tensor_latent_dims = []
+ for numel in self.param_numels:
+ d_m = math.ceil(numel / 2)
+ self.tensor_latent_dims.append(d_m)
+ for p in range(numel):
+ j = j_offset + p
+ k_local = p // 2
+ k_indices[j] = l_offset + k_local
+ if p % 2 == 0 and p == numel - 1:
+ weights[j] = 1.0
+ else:
+ weights[j] = inv_sqrt2
+ j_offset += numel
+ l_offset += d_m
+
+ self.k_indices = torch.tensor(k_indices, dtype=torch.long, device=device)
+ self.weights = torch.tensor(weights, dtype=torch.float32, device=device)
+ else:
+ self.tensor_latent_dims = list(self.param_numels)
+class AdjacentDifferenceLatentTransform(AdjacentPairLatentTransform):
+ """
+ Subclass of AdjacentPairLatentTransform that maps each parameter tensor independently
+ by assigning consecutive pairs of parameters to one unique latent coordinate with opposite weights
+ (+1/sqrt(2), -1/sqrt(2)), and a final unpaired parameter (if any) to weight 1.0,
+ concatenating tensor coordinate ranges without sharing.
+ """
+
+ def __init__(
+ self,
+ base_model: nn.Module,
+ geom_config: V6GeometryConfig,
+ device: torch.device,
+ ):
+ try:
+ super().__init__(base_model, geom_config, device)
+ except ValueError as e:
+ raise ValueError(
+ str(e).replace("AdjacentPairLatentTransform", "AdjacentDifferenceLatentTransform")
+ ) from None
+
+ if not self.is_full:
+ weights = self.weights.clone()
+ j_offset = 0
+ for numel in self.param_numels:
+ for p in range(1, numel, 2):
+ weights[j_offset + p] = -weights[j_offset + p]
+ j_offset += numel
+ self.weights = weights
+
+
+def format_ratio_id(
+ ratio: float,
+ geometry_policy: str = DEFAULT_GEOMETRY_POLICY,
+ projection_scope: Union[str, Dict[str, str]] = DEFAULT_PROJECTION_SCOPE,
+ projection_seed_mode: str = DEFAULT_PROJECTION_SEED_MODE,
+ projection_seed: Optional[Union[int, Dict[str, int]]] = None,
+ geometry_multiplier: float = DEFAULT_GEOMETRY_MULTIPLIER,
+) -> str:
+ validate_geometry_multiplier(geometry_multiplier)
+ validate_projection_seed_config(projection_seed_mode, projection_seed)
+ validate_projection_scope_config(projection_scope)
+ r_str = f"{ratio:g}"
+ base_id = f"aligned_r{r_str}" if geometry_policy == "baseline_aligned" else f"r{r_str}"
+ if isinstance(projection_scope, dict):
+ unique_scopes = set(projection_scope.values())
+ if len(unique_scopes) == 1:
+ eff_scope = next(iter(unique_scopes))
+ if eff_scope == "tensor_local":
+ base_id = f"local_{base_id}"
+ elif eff_scope == "balanced_global":
+ base_id = f"balanced_{base_id}"
+ elif eff_scope == "two_hash_global":
+ base_id = f"two_hash_{base_id}"
+ elif eff_scope == "largest_tensor_hash":
+ base_id = f"largest_tensor_hash_{base_id}"
+ elif eff_scope == "largest_tensor_row_hash":
+ base_id = f"largest_tensor_row_hash_{base_id}"
+ elif eff_scope == "adjacent_pair":
+ base_id = f"adjacent_pair_{base_id}"
+ elif eff_scope == "adjacent_difference":
+ base_id = f"adjacent_difference_{base_id}"
+ else:
+ base_id = f"mixed_{base_id}"
+ elif projection_scope == "tensor_local":
+ base_id = f"local_{base_id}"
+ elif projection_scope == "balanced_global":
+ base_id = f"balanced_{base_id}"
+ elif projection_scope == "two_hash_global":
+ base_id = f"two_hash_{base_id}"
+ elif projection_scope == "largest_tensor_hash":
+ base_id = f"largest_tensor_hash_{base_id}"
+ elif projection_scope == "largest_tensor_row_hash":
+ base_id = f"largest_tensor_row_hash_{base_id}"
+ elif projection_scope == "adjacent_pair":
+ base_id = f"adjacent_pair_{base_id}"
+ elif projection_scope == "adjacent_difference":
+ base_id = f"adjacent_difference_{base_id}"
+ if projection_seed_mode == "fixed":
+ base_id = f"fixed_{base_id}"
+ elif projection_seed_mode == "explicit":
+ if isinstance(projection_seed, dict):
+ base_id = f"pexplicit_{base_id}"
+ else:
+ base_id = f"p{projection_seed}_{base_id}"
+ if float(geometry_multiplier) != 1.0:
+ g_str = f"{geometry_multiplier:g}"
+ base_id = f"g{g_str}_{base_id}"
+ return base_id
+# Geometry Policies Assignment
+GEOMETRY_POLICIES: Dict[str, Dict[str, str]] = {
+ "recovered": {
+ "mnist_compact": "G6",
+ "mnist_wide": "G5",
+ "fashion_compact": "G6",
+ "fashion_wide": "G5",
+ },
+ "baseline_aligned": {
+ "mnist_compact": "G8",
+ "mnist_wide": "G5",
+ "fashion_compact": "G8",
+ "fashion_wide": "G5",
+ },
+}
+
+# Base Candidate Geometry Assignment (retained for backward compatibility)
+BASE_GEOMETRIES: Dict[str, str] = GEOMETRY_POLICIES["recovered"]
+BASELINE_METHODS: Dict[str, str] = {
+ "mnist_compact": "G8",
+ "mnist_wide": "G5",
+ "fashion_compact": "G8",
+ "fashion_wide": "G5",
+}
+
+
+
+def compute_latent_dim(total_dim: int, ratio: float) -> int:
+ """
+ Computes exact model-relative latent dimension from total parameter count and ratio.
+ Validates 0 < ratio <= 1.0 and uses deterministic half-up rounding floor(D*ratio+0.5).
+ Ensures dimension is at least 1 and capped at total_dim.
+ """
+ if not (0.0 < ratio <= 1.0):
+ raise ValueError(f"ratio must be in (0, 1], got {ratio}")
+ dim = int(math.floor(total_dim * ratio + 0.5))
+ return max(1, min(total_dim, dim))
+
+
+def derive_projection_seed(
+ workload_id: str,
+ ratio: float,
+ seed: int,
+ projection_salt: str = "",
+ mode: str = DEFAULT_PROJECTION_SEED_MODE,
+ projection_seed_mode: Optional[str] = None,
+ projection_seed: Optional[Union[int, Dict[str, int]]] = None,
+) -> int:
+ """
+ Derives a deterministic 32-bit projection seed from workload_id, ratio, swarm seed,
+ optional projection_salt, and projection seed mode ('coupled', 'fixed', or 'explicit').
+ In 'explicit' mode, returns projection_seed directly (or projection_seed[workload_id] if a dict).
+ """
+ if projection_seed_mode is not None:
+ mode = projection_seed_mode
+ validate_projection_seed_config(mode, projection_seed)
+ if mode == "explicit":
+ if isinstance(projection_seed, dict):
+ if workload_id not in projection_seed:
+ raise ValueError(f"Missing explicit projection_seed for workload '{workload_id}'")
+ return projection_seed[workload_id]
+ assert projection_seed is not None
+ return projection_seed
+ parts = [workload_id, f"{ratio:.5f}"]
+ if mode != "fixed":
+ parts.append(str(seed))
+ if projection_salt:
+ parts.append(projection_salt)
+ key = ":".join(parts).encode("utf-8")
+ h = hashlib.sha256(key).hexdigest()
+ return int(h[:8], 16) % (2**31 - 1)
+
+def construct_equalized_geometry(
+ base_geom: V6GeometryConfig,
+ total_dim: int,
+ latent_dim: int,
+ projection_seed: int,
+ ratio_str: str = "",
+ geometry_multiplier: float = DEFAULT_GEOMETRY_MULTIPLIER,
+) -> V6GeometryConfig:
+ """
+ Constructs an equalized subspace geometry configuration from a base geometry (G6 or G5).
+ Multiplies position radius, launch velocity radius, mutation reset radius, and reflective bound
+ by sqrt(total_dim / latent_dim) * geometry_multiplier to hold decoded per-parameter variance constant.
+ """
+ validate_geometry_multiplier(geometry_multiplier)
+ scale_factor = math.sqrt(total_dim / latent_dim) if latent_dim < total_dim else 1.0
+ effective_mult = scale_factor * float(geometry_multiplier)
+ return V6GeometryConfig(
+ config_id=f"{base_geom.config_id}_eq_{ratio_str}",
+ scale_type=base_geom.scale_type,
+ init_position_mode=base_geom.init_position_mode,
+ position_radius=float(base_geom.position_radius * effective_mult),
+ initial_velocity_radius=float(base_geom.initial_velocity_radius * effective_mult),
+ mutation_prob=base_geom.mutation_prob,
+ reset_velocity_radius=float(base_geom.reset_velocity_radius * effective_mult),
+ reflective_bound=float(base_geom.reflective_bound * effective_mult),
+ projection_seed=projection_seed,
+ latent_dim=latent_dim,
+ description=f"Equalized subspace (ratio={ratio_str}, d={latent_dim}/{total_dim})",
+ )
+
+def compute_core_swarm_state_bytes(particles: int, latent_dim: int) -> int:
+ """
+ Computes exact core swarm state memory footprint in bytes.
+ 5 tensors (Z, V, M, V_sq, P) of size (particles, latent_dim) float32 (4 bytes/elem).
+ """
+ return 5 * particles * latent_dim * 4
+
+def compute_baseline_core_swarm_state_bytes(
+ workload_id: str,
+ particles: int,
+ total_dim: int,
+) -> int:
+ """Match the retained baseline method's persistent core-state accounting."""
+ particle_states = 5 * particles
+ if BASELINE_METHODS[workload_id] == "G8":
+ particle_states += 1
+ return particle_states * total_dim * 4
+
+
+
+
+def run_heavy_pso_autoresearch(
+ ratios: Sequence[float] = DEFAULT_RATIOS,
+ particles: int = DEFAULT_PARTICLES,
+ epochs: int = DEFAULT_EPOCHS,
+ subset_size: int = DEFAULT_SUBSET_SIZE,
+ seeds: Sequence[int] = DEFAULT_SEEDS,
+ geometry_policy: str = DEFAULT_GEOMETRY_POLICY,
+ device_str: Optional[str] = None,
+ cache_dir: Optional[Path] = None,
+ output_path: Optional[Path] = None,
+ split_seed: int = DEFAULT_SPLIT_SEED,
+ projection_salt: str = "",
+ projection_scope: Union[str, Dict[str, str]] = DEFAULT_PROJECTION_SCOPE,
+ projection_seed_mode: str = DEFAULT_PROJECTION_SEED_MODE,
+ projection_seed: Optional[Union[int, Dict[str, int]]] = None,
+ geometry_multiplier: float = DEFAULT_GEOMETRY_MULTIPLIER,
+) -> Dict[str, Any]:
+ """
+ Executes the heavy task autoresearch experiment candidate runs across candidate ratios,
+ workloads, and seeds. Aggregates metrics and atomically writes the candidate JSON artifact.
+ """
+ validate_geometry_multiplier(geometry_multiplier)
+ validate_projection_seed_config(projection_seed_mode, projection_seed)
+ validate_projection_scope_config(projection_scope)
+ if geometry_policy not in GEOMETRY_POLICIES:
+ raise ValueError(
+ f"Invalid geometry_policy '{geometry_policy}'. Must be one of {list(GEOMETRY_POLICIES.keys())}"
+ )
+ policy_geometries = GEOMETRY_POLICIES[geometry_policy]
+
+ start_time = time.time()
+ device = resolve_execution_device(device_str)
+ hardware_info = get_hardware_provenance(device)
+ geom_table = get_v6_geometry_table()
+
+ if cache_dir is None:
+ cache_dir = REPO_ROOT / "result" / "cache"
+
+ data_cache: Dict[str, Any] = {}
+ workload_meta: Dict[str, Any] = {}
+
+ # Pre-load datasets and models metadata
+ for wl_id, wl_cfg in WORKLOADS.items():
+ if wl_cfg.dataset_name not in data_cache:
+ x_search, y_search, x_val, y_val, nested_subsets, data_fp, provenance = prepare_heavy_task_data(
+ dataset_name=wl_cfg.dataset_name,
+ split_seed=split_seed,
+ cache_dir=cache_dir,
+ )
+ data_cache[wl_cfg.dataset_name] = {
+ "x_search": x_search,
+ "y_search": y_search,
+ "x_val": x_val,
+ "y_val": y_val,
+ "nested_subsets": nested_subsets,
+ "data_fp": data_fp,
+ "provenance": provenance,
+ }
+
+ bm = create_model(wl_cfg.model_name, seed=41)
+ param_count = sum(p.numel() for p in bm.parameters())
+ model_fp = compute_model_fingerprint(bm)
+ d_info = data_cache[wl_cfg.dataset_name]
+
+ eff_proj_seed = (
+ projection_seed[wl_id]
+ if isinstance(projection_seed, dict)
+ else projection_seed
+ )
+
+ workload_meta[wl_id] = {
+ "workload_id": wl_id,
+ "dataset_name": wl_cfg.dataset_name,
+ "model_name": wl_cfg.model_name,
+ "parameter_count": param_count,
+ "total_dim": param_count,
+ "geometry_policy": geometry_policy,
+ "geometry_multiplier": float(geometry_multiplier),
+ "projection_scope": get_effective_projection_scope(projection_scope, wl_id),
+ "projection_seed_mode": str(projection_seed_mode),
+ "projection_seed": eff_proj_seed,
+ "base_geometry_id": policy_geometries[wl_id],
+ "model_fingerprint": model_fp,
+ "data_fingerprint": d_info["data_fp"],
+ "split_fingerprint": d_info["provenance"]["split_fingerprint"],
+ "description": wl_cfg.description,
+ }
+
+ candidate_runs: Dict[str, Dict[str, Any]] = {}
+ total_runs_executed = 0
+ total_queries_executed = 0
+ total_samples_evaluated = 0
+
+ for r in ratios:
+ ratio_id = format_ratio_id(
+ r,
+ geometry_policy=geometry_policy,
+ projection_scope=projection_scope,
+ projection_seed_mode=projection_seed_mode,
+ projection_seed=projection_seed,
+ geometry_multiplier=geometry_multiplier,
+ )
+ wl_candidates: Dict[str, Any] = {}
+
+ for wl_id, wl_cfg in WORKLOADS.items():
+ d_info = data_cache[wl_cfg.dataset_name]
+ x_search, y_search = d_info["x_search"], d_info["y_search"]
+ x_val, y_val = d_info["x_val"], d_info["y_val"]
+ nested_subsets = d_info["nested_subsets"]
+
+ base_model = create_model(wl_cfg.model_name, seed=41)
+ total_dim = sum(p.numel() for p in base_model.parameters())
+ latent_dim = compute_latent_dim(total_dim, r)
+ base_geom_id = policy_geometries[wl_id]
+ base_geom = geom_table[base_geom_id]
+ state_bytes = compute_core_swarm_state_bytes(particles, latent_dim)
+ baseline_state_bytes = compute_baseline_core_swarm_state_bytes(
+ workload_id=wl_id,
+ particles=particles,
+ total_dim=total_dim,
+ )
+
+ per_seed_runs: List[Dict[str, Any]] = []
+
+ for s in seeds:
+ proj_seed = derive_projection_seed(
+ wl_id,
+ r,
+ s,
+ projection_salt=projection_salt,
+ mode=projection_seed_mode,
+ projection_seed=projection_seed,
+ )
+ geom_cfg = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=latent_dim,
+ projection_seed=proj_seed,
+ ratio_str=ratio_id,
+ geometry_multiplier=geometry_multiplier,
+ )
+
+ eff_scope = get_effective_projection_scope(projection_scope, wl_id)
+ if eff_scope == "tensor_local":
+ transform = TensorLocalLatentTransform(base_model, geom_cfg, device)
+ elif eff_scope == "balanced_global":
+ transform = BalancedGlobalLatentTransform(base_model, geom_cfg, device)
+ elif eff_scope == "two_hash_global":
+ transform = TwoHashGlobalLatentTransform(base_model, geom_cfg, device)
+ elif eff_scope == "largest_tensor_hash":
+ transform = LargestTensorHashLatentTransform(base_model, geom_cfg, device)
+ elif eff_scope == "largest_tensor_row_hash":
+ transform = LargestTensorRowHashLatentTransform(base_model, geom_cfg, device)
+ elif eff_scope == "adjacent_pair":
+ transform = AdjacentPairLatentTransform(base_model, geom_cfg, device)
+ elif eff_scope == "adjacent_difference":
+ transform = AdjacentDifferenceLatentTransform(base_model, geom_cfg, device)
+ elif eff_scope == "global":
+ transform = V6LatentTransform(base_model, geom_cfg, device)
+ else:
+ raise ValueError(f"Invalid effective projection_scope '{eff_scope}' for workload '{wl_id}'")
+ res = run_v6_pso(
+ transform=transform,
+ base_model=base_model,
+ x_search=x_search,
+ y_search=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ nested_subsets=nested_subsets,
+ schedule_str=f"{subset_size}:{epochs}",
+ epochs=epochs,
+ swarm_size=particles,
+ seed=s,
+ device=device,
+ geom_config=geom_cfg,
+ val_check_interval=10,
+ )
+
+ opt_time = max(float(res["optimization_wall_time_sec"]), 1e-6)
+ sps = round(float(res["total_sample_evaluations"]) / opt_time, 2)
+ val_metrics_raw = artifact_safe_run(res.get("val_metrics", {}))
+ has_valid_val_metrics = (
+ isinstance(val_metrics_raw, dict)
+ and len(val_metrics_raw) > 0
+ and all(
+ isinstance(v, (int, float)) and math.isfinite(float(v))
+ for v in val_metrics_raw.values()
+ )
+ )
+ scalar_metrics = [
+ res.get("val_selected_loss"),
+ res.get("val_selected_acc"),
+ res.get("gbest_loss"),
+ res.get("gbest_acc"),
+ res.get("wall_time_sec"),
+ res.get("optimization_wall_time_sec"),
+ res.get("validation_wall_time_sec"),
+ sps,
+ ]
+ has_valid_scalars = all(
+ v is not None and isinstance(v, (int, float)) and math.isfinite(float(v))
+ for v in scalar_metrics
+ )
+ is_finite = bool(has_valid_val_metrics and has_valid_scalars)
+
+ seed_record = {
+ "seed": int(s),
+ "projection_seed": int(proj_seed),
+ "projection_salt": str(projection_salt),
+ "projection_scope": get_effective_projection_scope(projection_scope, wl_id),
+ "projection_seed_mode": str(projection_seed_mode),
+ "geometry_multiplier": float(geometry_multiplier),
+ "val_selected_loss": float(res["val_selected_loss"]),
+ "val_selected_acc": float(res["val_selected_acc"]),
+ "val_metrics": val_metrics_raw,
+ "gbest_loss": float(res["gbest_loss"]),
+ "gbest_acc": float(res["gbest_acc"]),
+ "wall_time_sec": float(res["wall_time_sec"]),
+ "optimization_wall_time_sec": float(res["optimization_wall_time_sec"]),
+ "validation_wall_time_sec": float(res["validation_wall_time_sec"]),
+ "total_queries": int(res["total_queries"]),
+ "total_sample_evaluations": int(res["total_sample_evaluations"]),
+ "validation_evaluations": int(res["validation_evaluations"]),
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": int(state_bytes),
+ "throughput_samples_per_sec": float(sps),
+ "is_finite": is_finite,
+ }
+ per_seed_runs.append(seed_record)
+
+ total_runs_executed += 1
+ total_queries_executed += int(res["total_queries"])
+ total_samples_evaluated += int(res["total_sample_evaluations"])
+
+ # Statistics calculation across seeds
+ acc_list = [r_entry["val_selected_acc"] for r_entry in per_seed_runs]
+ nll_list = [r_entry["val_selected_loss"] for r_entry in per_seed_runs]
+ brier_list = [r_entry["val_metrics"]["brier"] for r_entry in per_seed_runs if r_entry.get("val_metrics")]
+ ece_list = [r_entry["val_metrics"]["ece"] for r_entry in per_seed_runs if r_entry.get("val_metrics")]
+ g_loss_list = [r_entry["gbest_loss"] for r_entry in per_seed_runs]
+ g_acc_list = [r_entry["gbest_acc"] for r_entry in per_seed_runs]
+ wall_list = [r_entry["wall_time_sec"] for r_entry in per_seed_runs]
+ opt_wall_list = [r_entry["optimization_wall_time_sec"] for r_entry in per_seed_runs]
+ sps_list = [r_entry["throughput_samples_per_sec"] for r_entry in per_seed_runs]
+
+ stats = {
+ "val_acc": calc_stats(acc_list),
+ "val_nll": calc_stats(nll_list),
+ "val_brier": calc_stats(brier_list) if brier_list else None,
+ "val_ece": calc_stats(ece_list) if ece_list else None,
+ "gbest_loss": calc_stats(g_loss_list),
+ "gbest_acc": calc_stats(g_acc_list),
+ "wall_time_sec": calc_stats(wall_list),
+ "optimization_wall_time_sec": calc_stats(opt_wall_list),
+ "throughput_samples_per_sec": calc_stats(sps_list),
+ }
+
+ state_ratio = float(state_bytes / baseline_state_bytes)
+
+ wl_candidates[wl_id] = {
+ "candidate_id": ratio_id,
+ "ratio": float(r),
+ "workload_id": wl_id,
+ "geometry_policy": geometry_policy,
+ "geometry_multiplier": float(geometry_multiplier),
+ "projection_scope": get_effective_projection_scope(projection_scope, wl_id),
+ "projection_seed_mode": str(projection_seed_mode),
+ "projection_seed": (
+ projection_seed[wl_id]
+ if isinstance(projection_seed, dict)
+ else projection_seed
+ ),
+ "base_geometry_id": base_geom_id,
+ "total_dim": total_dim,
+ "latent_dim": latent_dim,
+ "state_ratio": state_ratio,
+ "subset_size": subset_size,
+ "particles": particles,
+ "epochs": epochs,
+ "seeds": list(seeds),
+ "core_swarm_state_bytes": state_bytes,
+ "baseline_core_swarm_state_bytes": baseline_state_bytes,
+ "split_seed": int(split_seed),
+ "data_fingerprint": d_info["data_fp"],
+ "split_fingerprint": d_info["provenance"]["split_fingerprint"],
+ "stats": stats,
+ "per_seed_runs": per_seed_runs,
+ }
+
+ candidate_runs[ratio_id] = wl_candidates
+
+ total_wall_time = round(time.time() - start_time, 4)
+
+ payload = {
+ "protocol_version": AUTORESEARCH_PROTOCOL_VERSION,
+ "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+ "hardware": hardware_info,
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "experiment_config": {
+ "geometry_policy": geometry_policy,
+ "geometry_multiplier": float(geometry_multiplier),
+ "projection_scope": projection_scope,
+ "projection_seed_mode": str(projection_seed_mode),
+ "projection_seed": projection_seed,
+ "projection_salt": str(projection_salt),
+ "ratios": [float(r) for r in ratios],
+ "particles": int(particles),
+ "epochs": int(epochs),
+ "subset_size": int(subset_size),
+ "seeds": [int(s) for s in seeds],
+ "split_seed": int(split_seed),
+ "total_runs": total_runs_executed,
+ "total_queries": total_queries_executed,
+ "total_sample_evaluations": total_samples_evaluated,
+ "total_wall_time_sec": total_wall_time,
+ },
+ "workloads": workload_meta,
+ "candidate_runs": candidate_runs,
+ }
+
+ if output_path is not None:
+ save_json_atomic(payload, Path(output_path))
+
+ return payload
+
+
+def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(
+ description="MNIST / FashionMNIST PSO Heavy Autoresearch Candidate Experiment Runner"
+ )
+ parser.add_argument("--device", type=str, default=None, help="Device (cpu, mps, cuda)")
+ parser.add_argument("--cache-dir", type=str, default=None, help="Dataset cache directory")
+ parser.add_argument(
+ "--split-seed",
+ type=int,
+ default=DEFAULT_SPLIT_SEED,
+ help=f"Dataset train/validation split seed (default: {DEFAULT_SPLIT_SEED})",
+ )
+ parser.add_argument(
+ "--output",
+ type=str,
+ default="benchmark_results/pso_v6_heavy_autoresearch_candidates.json",
+ help="Output candidate JSON path",
+ )
+ parser.add_argument(
+ "--geometry-policy",
+ type=str,
+ default=DEFAULT_GEOMETRY_POLICY,
+ choices=list(GEOMETRY_POLICIES.keys()),
+ help="Geometry policy ('recovered' or 'baseline_aligned')",
+ )
+ parser.add_argument(
+ "--ratios",
+ type=str,
+ default="1,0.5,0.25,0.125,0.03125",
+ help="Comma-separated latent subspace ratios",
+ )
+ parser.add_argument("--particles", type=int, default=DEFAULT_PARTICLES, help="Swarm size")
+ parser.add_argument("--epochs", type=int, default=DEFAULT_EPOCHS, help="PSO epochs")
+ parser.add_argument(
+ "--subset-size",
+ type=int,
+ default=DEFAULT_SUBSET_SIZE,
+ help="Training subset size",
+ )
+ parser.add_argument("--seeds", type=str, default="101,102,103", help="Comma-separated seeds")
+ parser.add_argument(
+ "--projection-salt",
+ type=str,
+ default="",
+ help="Optional salt string for projection seed derivation (default: empty)",
+ )
+ parser.add_argument(
+ "--projection-scope",
+ type=parse_projection_scope_arg,
+ default=DEFAULT_PROJECTION_SCOPE,
+ help="Projection scope ('global', 'tensor_local', 'balanced_global', 'two_hash_global', 'largest_tensor_hash', 'largest_tensor_row_hash', 'adjacent_pair', 'adjacent_difference', or workload dict)",
+ )
+ parser.add_argument(
+ "--projection-seed-mode",
+ type=str,
+ default=DEFAULT_PROJECTION_SEED_MODE,
+ choices=list(PROJECTION_SEED_MODES),
+ help="Projection seed mode ('coupled', 'fixed', or 'explicit')",
+ )
+ parser.add_argument(
+ "--projection-seed",
+ type=parse_projection_seed_arg,
+ default=None,
+ help="Exact nonnegative projection seed (int or dict) for explicit mode",
+ )
+ parser.add_argument(
+ "--geometry-multiplier",
+ type=float,
+ default=DEFAULT_GEOMETRY_MULTIPLIER,
+ help="Geometry radius/bound multiplier (default: 1.0)",
+ )
+ return parser
+
+
+def main():
+ parser = build_parser()
+ args = parser.parse_args()
+
+ ratios = [float(x.strip()) for x in args.ratios.split(",") if x.strip()]
+ seeds = [int(x.strip()) for x in args.seeds.split(",") if x.strip()]
+ cache_path = Path(args.cache_dir) if args.cache_dir else None
+ out_path = Path(args.output) if args.output else None
+
+ run_heavy_pso_autoresearch(
+ ratios=ratios,
+ split_seed=args.split_seed,
+ projection_seed_mode=args.projection_seed_mode,
+ projection_seed=args.projection_seed,
+ particles=args.particles,
+ epochs=args.epochs,
+ subset_size=args.subset_size,
+ seeds=seeds,
+ geometry_policy=args.geometry_policy,
+ device_str=args.device,
+ cache_dir=cache_path,
+ output_path=out_path,
+ projection_salt=args.projection_salt,
+ projection_scope=args.projection_scope,
+ geometry_multiplier=args.geometry_multiplier,
+ )
+
+if __name__ == "__main__":
+ main()
diff --git a/test/heavy_pso_cross_split.py b/test/heavy_pso_cross_split.py
new file mode 100644
index 0000000..0685672
--- /dev/null
+++ b/test/heavy_pso_cross_split.py
@@ -0,0 +1,335 @@
+"""
+Heavy PSO Cross-Split Experiment Runner.
+
+Protocol Version: HEAVY-PSO-CROSS-SPLIT 1.0.0
+
+Runs matching baseline and candidate PSO experiments across development or confirmation
+data splits under sealed official test conditions (official_test_evaluations = 0).
+
+Phase Specifications:
+- Development: split_seeds = (20260905, 20260906), swarm_seeds = (101, 102, 103)
+- Confirmation: split_seeds = (20260907,), swarm_seeds = (111, 112, 113)
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+# Ensure test directory and repo root are in Python path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+from benchmark_suite import (
+ get_hardware_provenance,
+ resolve_execution_device,
+ save_json_atomic,
+)
+from heavy_pso_autoresearch import (
+ DEFAULT_GEOMETRY_MULTIPLIER,
+ parse_projection_seed_arg,
+ parse_projection_scope_arg,
+ validate_projection_scope_config,
+ get_effective_projection_scope,
+ run_heavy_pso_autoresearch,
+)
+from heavy_task_feasibility import (
+ WORKLOADS,
+ run_heavy_task_confirm,
+)
+from pso import __version__ as pso_version
+
+PROTOCOL_VERSION = "HEAVY-PSO-CROSS-SPLIT 1.0.0"
+
+PHASE_CONFIGS = {
+ "development": {
+ "split_seeds": [20260905, 20260906],
+ "swarm_seeds": [101, 102, 103],
+ },
+ "confirmation": {
+ "split_seeds": [20260907],
+ "swarm_seeds": [111, 112, 113],
+ },
+}
+
+WORKLOAD_BASELINE_METHODS = {
+ "mnist_compact": "G8",
+ "mnist_wide": "G5",
+ "fashion_compact": "G8",
+ "fashion_wide": "G5",
+}
+
+FROZEN_PROJECTION_SEEDS = {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 592157828,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 189641451,
+}
+
+
+def run_heavy_pso_cross_split(
+ phase: str = "development",
+ ratio: float = 0.5,
+ geometry_policy: str = "baseline_aligned",
+ projection_scope: Union[str, Dict[str, str]] = "global",
+ projection_seed_mode: str = "explicit",
+ projection_seed: Optional[Union[int, Dict[str, int]]] = None,
+ geometry_multiplier: float = DEFAULT_GEOMETRY_MULTIPLIER,
+ particles: int = 12,
+ epochs: int = 80,
+ subset_size: int = 10000,
+ device_str: Optional[str] = None,
+ cache_dir: Optional[Path] = None,
+ output_path: Optional[Path] = None,
+) -> Dict[str, Any]:
+ """
+ Runs cross-split evaluation for development or confirmation phase.
+ Enforces exact split and swarm seed contracts for each phase.
+ Reruns matching baseline and candidate models per split seed.
+ """
+ projection_scope = parse_projection_scope_arg(projection_scope)
+ validate_projection_scope_config(projection_scope)
+ if phase not in PHASE_CONFIGS:
+ raise ValueError(
+ f"Invalid phase '{phase}'. Must be one of {list(PHASE_CONFIGS.keys())}"
+ )
+
+ phase_spec = PHASE_CONFIGS[phase]
+ split_seeds = phase_spec["split_seeds"]
+ swarm_seeds = phase_spec["swarm_seeds"]
+
+ if projection_seed_mode == "explicit" and projection_seed is None:
+ projection_seed = dict(FROZEN_PROJECTION_SEEDS)
+
+ start_time = time.time()
+ device = resolve_execution_device(device_str)
+ hardware_info = get_hardware_provenance(device)
+
+ if cache_dir is None:
+ cache_dir = REPO_ROOT / "result" / "cache"
+
+ splits_payload: Dict[str, Any] = {}
+ total_runs = 0
+ total_queries = 0
+ total_samples_evaluated = 0
+
+ for split_seed in split_seeds:
+ # 1. Baseline runs for this split seed
+ selected_baseline_methods = {
+ wl_id: [WORKLOAD_BASELINE_METHODS[wl_id]] for wl_id in WORKLOADS
+ }
+ baseline_res = run_heavy_task_confirm(
+ workloads=WORKLOADS,
+ selected_methods=selected_baseline_methods,
+ particles=particles,
+ epochs=epochs,
+ seeds=swarm_seeds,
+ split_seed=split_seed,
+ device=device,
+ cache_dir=cache_dir,
+ )
+
+ # 2. Candidate runs for this split seed
+ candidate_res = run_heavy_pso_autoresearch(
+ ratios=[ratio],
+ particles=particles,
+ epochs=epochs,
+ subset_size=subset_size,
+ seeds=swarm_seeds,
+ geometry_policy=geometry_policy,
+ device_str=device_str,
+ cache_dir=cache_dir,
+ split_seed=split_seed,
+ projection_scope=projection_scope,
+ projection_seed_mode=projection_seed_mode,
+ projection_seed=projection_seed,
+ geometry_multiplier=geometry_multiplier,
+ )
+
+ # Extract candidate ratio payload
+ candidate_ratio_runs = list(candidate_res["candidate_runs"].values())[0]
+
+ baselines_split: Dict[str, Any] = {}
+ candidates_split: Dict[str, Any] = {}
+ dataset_fingerprints: Dict[str, str] = {}
+ split_fingerprints: Dict[str, str] = {}
+
+ for wl_id in WORKLOADS:
+ b_method = WORKLOAD_BASELINE_METHODS[wl_id]
+ b_entry = baseline_res[wl_id][b_method]
+ baselines_split[wl_id] = b_entry
+
+ c_entry = candidate_ratio_runs[wl_id]
+ candidates_split[wl_id] = c_entry
+
+ dataset_name = WORKLOADS[wl_id].dataset_name
+ dataset_fingerprints[dataset_name] = c_entry["data_fingerprint"]
+ split_fingerprints[dataset_name] = c_entry["split_fingerprint"]
+
+ # Resource accumulation
+ for r in b_entry["per_seed_runs"]:
+ total_runs += 1
+ total_queries += r["total_queries"]
+ total_samples_evaluated += r["total_sample_evaluations"]
+ for r in c_entry["per_seed_runs"]:
+ total_runs += 1
+ total_queries += r["total_queries"]
+ total_samples_evaluated += r["total_sample_evaluations"]
+
+ splits_payload[str(split_seed)] = {
+ "split_seed": split_seed,
+ "data_fingerprints": dataset_fingerprints,
+ "split_fingerprints": split_fingerprints,
+ "baselines": baselines_split,
+ "candidates": candidates_split,
+ }
+
+ payload = {
+ "version": PROTOCOL_VERSION,
+ "protocol_version": PROTOCOL_VERSION,
+ "phase": phase,
+ "split_seeds": list(split_seeds),
+ "swarm_seeds": list(swarm_seeds),
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "candidate_config": {
+ "ratio": ratio,
+ "geometry_policy": geometry_policy,
+ "projection_scope": projection_scope,
+ "projection_seed_mode": projection_seed_mode,
+ "projection_seed": projection_seed,
+ "geometry_multiplier": float(geometry_multiplier),
+ "particles": particles,
+ "epochs": epochs,
+ "subset_size": subset_size,
+ },
+ "workloads": {
+ wl_id: {
+ "workload_id": wl_id,
+ "dataset_name": wl_cfg.dataset_name,
+ "model_name": wl_cfg.model_name,
+ "baseline_method": WORKLOAD_BASELINE_METHODS[wl_id],
+ "projection_scope": get_effective_projection_scope(projection_scope, wl_id),
+ "effective_projection_seed": (
+ projection_seed[wl_id]
+ if isinstance(projection_seed, dict)
+ else projection_seed
+ ),
+ }
+ for wl_id, wl_cfg in WORKLOADS.items()
+ },
+ "splits": splits_payload,
+ "resource_totals": {
+ "total_runs": total_runs,
+ "total_queries": total_queries,
+ "total_samples_evaluated": total_samples_evaluated,
+ "official_test_evaluations": 0,
+ "wall_time_sec": round(time.time() - start_time, 4),
+ },
+ "provenance": {
+ "hardware": hardware_info,
+ "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+ "pso_version": pso_version,
+ },
+ }
+
+ if output_path is not None:
+ save_json_atomic(payload, output_path)
+
+ return payload
+
+
+def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(
+ description="Heavy PSO Cross-Split Experiment Runner (Development / Confirmation)"
+ )
+ parser.add_argument(
+ "--phase",
+ type=str,
+ default="development",
+ choices=list(PHASE_CONFIGS.keys()),
+ help="Experiment phase ('development' or 'confirmation')",
+ )
+ parser.add_argument("--device", type=str, default=None, help="Device (cpu, mps, cuda)")
+ parser.add_argument("--cache-dir", type=str, default=None, help="Dataset cache directory")
+ parser.add_argument("--output", type=str, default=None, help="Output artifact JSON path")
+ parser.add_argument(
+ "--ratio",
+ type=float,
+ default=0.5,
+ help="Subspace ratio for candidate PSO (default: 0.5)",
+ )
+ parser.add_argument(
+ "--geometry-policy",
+ type=str,
+ default="baseline_aligned",
+ help="Geometry policy (default: 'baseline_aligned')",
+ )
+ parser.add_argument(
+ "--projection-scope",
+ type=parse_projection_scope_arg,
+ default="global",
+ help="Projection scope ('global', 'tensor_local', 'balanced_global', 'two_hash_global', 'largest_tensor_hash', 'largest_tensor_row_hash', 'adjacent_pair', 'adjacent_difference', or workload dict)",
+ )
+ parser.add_argument(
+ "--projection-seed-mode",
+ type=str,
+ default="explicit",
+ help="Projection seed mode (default: 'explicit')",
+ )
+ parser.add_argument(
+ "--projection-seed",
+ type=parse_projection_seed_arg,
+ default=None,
+ help="Exact projection seed (int or dict) for explicit mode",
+ )
+ parser.add_argument(
+ "--geometry-multiplier",
+ type=float,
+ default=DEFAULT_GEOMETRY_MULTIPLIER,
+ help="Geometry multiplier (default: 1.0)",
+ )
+ parser.add_argument("--particles", type=int, default=12, help="Swarm size (default: 12)")
+ parser.add_argument("--epochs", type=int, default=80, help="PSO epochs (default: 80)")
+ parser.add_argument(
+ "--subset-size",
+ type=int,
+ default=10000,
+ help="Subset size (default: 10000)",
+ )
+ return parser
+
+
+def main():
+ parser = build_parser()
+ args = parser.parse_args()
+
+ cache_path = Path(args.cache_dir) if args.cache_dir else None
+ out_path = Path(args.output) if args.output else None
+
+ run_heavy_pso_cross_split(
+ phase=args.phase,
+ ratio=args.ratio,
+ geometry_policy=args.geometry_policy,
+ projection_scope=args.projection_scope,
+ projection_seed_mode=args.projection_seed_mode,
+ projection_seed=args.projection_seed,
+ geometry_multiplier=args.geometry_multiplier,
+ particles=args.particles,
+ epochs=args.epochs,
+ subset_size=args.subset_size,
+ device_str=args.device,
+ cache_dir=cache_path,
+ output_path=out_path,
+ )
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/heavy_task_feasibility.py b/test/heavy_task_feasibility.py
new file mode 100644
index 0000000..54c2575
--- /dev/null
+++ b/test/heavy_task_feasibility.py
@@ -0,0 +1,1190 @@
+"""
+Heavy Task Feasibility Study: Parameter Dimension & Data Hardness Scaling.
+
+Protocol Version: HEAVY-TASK-PSO-V6 1.0.0
+
+Feasibility probe to test retained PSO methods (G0, G5, G6, G8) along two axes:
+1. Larger Parameter Dimension (WideCNN ~55k params vs CompactCNN 9,098 params)
+2. Harder Data (FashionMNIST vs MNIST)
+
+Workload Matrix (4 workloads x 4 methods = 16 screen cells):
+- mnist_compact (MNIST + CompactCNN 9,098 params, control)
+- mnist_wide (MNIST + WideCNN ~55k params, parameter scaling axis)
+- fashion_compact (FashionMNIST + CompactCNN 9,098 params, data hardness axis)
+- fashion_wide (FashionMNIST + WideCNN ~55k params, combined axis)
+
+Methods: G0, G5, G6, G8
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+from dataclasses import dataclass, asdict
+import hashlib
+import json
+import csv
+import math
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+from sklearn.model_selection import train_test_split
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+
+# Ensure test directory and repo root are in Python path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+from benchmark_suite import (
+ calc_stats,
+ compute_model_fingerprint,
+ get_hardware_provenance,
+ resolve_execution_device,
+ save_json_atomic,
+ sync_device,
+)
+from deep_pso_methods import (
+ CompactCNN,
+ make_compact_cnn,
+ build_nested_stratified_subsets,
+ evaluate_probabilistic_metrics,
+ get_model_probabilities,
+)
+from deep_pso_v6 import (
+ V6GeometryConfig,
+ get_v6_geometry_table,
+ V6LatentTransform,
+ run_v6_pso,
+ run_g8_optimizer,
+)
+from pso import __version__ as pso_version
+
+PROTOCOL_VERSION = "HEAVY-TASK-PSO-V6 1.0.0"
+FEASIBILITY_NLL_REDUCTION = 0.20
+FEASIBILITY_ACCURACY_GAIN_PP = 20.0
+
+
+
+# =====================================================================
+# 1. Architecture Definitions & Deterministic Factories
+# =====================================================================
+
+class WideCNN(nn.Module):
+ """
+ WideCNN architecture (~55,338 parameters):
+ Conv1 (1->16, 3x3, pad=1), ReLU, MaxPool2d(2,2)
+ Conv2 (16->32, 3x3, pad=1), ReLU, MaxPool2d(2,2)
+ Flatten -> 32x7x7 = 1568
+ Linear (1568 -> 32), ReLU
+ Linear (32 -> 10)
+ """
+ def __init__(self):
+ super().__init__()
+ self.conv1 = nn.Conv2d(1, 16, kernel_size=3, padding=1)
+ self.relu1 = nn.ReLU()
+ self.pool1 = nn.MaxPool2d(2, 2)
+ self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
+ self.relu2 = nn.ReLU()
+ self.pool2 = nn.MaxPool2d(2, 2)
+ self.flatten = nn.Flatten()
+ self.fc1 = nn.Linear(1568, 32)
+ self.relu3 = nn.ReLU()
+ self.fc2 = nn.Linear(32, 10)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if x.dim() == 2 and x.shape[1] == 784:
+ x = x.view(-1, 1, 28, 28)
+ out = self.pool1(self.relu1(self.conv1(x)))
+ out = self.pool2(self.relu2(self.conv2(out)))
+ out = self.flatten(out)
+ out = self.relu3(self.fc1(out))
+ return self.fc2(out)
+
+
+def make_wide_cnn(seed: int = 41) -> nn.Module:
+ """Deterministic factory for WideCNN by seed."""
+ torch.manual_seed(seed)
+ return WideCNN()
+
+
+def create_model(model_name: str, seed: int = 41) -> nn.Module:
+ """Factory function creating a model instance by name and seed."""
+ name = model_name.lower()
+ if name in ("compact_cnn", "compactcnn"):
+ return make_compact_cnn(seed)
+ elif name in ("wide_cnn", "widecnn"):
+ return make_wide_cnn(seed)
+ else:
+ raise ValueError(f"Unknown model architecture name: '{model_name}'. Expected 'compact_cnn' or 'wide_cnn'.")
+
+
+# =====================================================================
+# 2. Generic Train-Only Data Preparation (MNIST & FashionMNIST)
+# =====================================================================
+
+def prepare_heavy_task_data(
+ dataset_name: str,
+ split_seed: int = 20260902,
+ cache_dir: Optional[Path] = None,
+) -> Tuple[
+ torch.Tensor, torch.Tensor,
+ torch.Tensor, torch.Tensor,
+ Dict[int, torch.Tensor],
+ str, Dict[str, Any]
+]:
+ """
+ Train-only data preparation for MNIST or FashionMNIST using exclusively train=True.
+ Never constructs train=False.
+ Preserves exact split seed (20260902), search-only normalization,
+ and nested 2k/10k/50k index stratification.
+ """
+ if cache_dir is None:
+ cache_dir = Path("result/cache")
+ cache_dir.mkdir(parents=True, exist_ok=True)
+
+ ds_lower = dataset_name.lower()
+ if ds_lower in ("mnist", "mnist_compact", "mnist_wide"):
+ from torchvision.datasets import MNIST
+ raw_train = MNIST(root=str(cache_dir), train=True, download=True)
+ canonical_name = "MNIST"
+ elif ds_lower in ("fashion_mnist", "fashion", "fashion_compact", "fashion_wide"):
+ from torchvision.datasets import FashionMNIST
+ raw_train = FashionMNIST(root=str(cache_dir), train=True, download=True)
+ canonical_name = "FashionMNIST"
+ else:
+ raise ValueError(f"Unsupported dataset name: '{dataset_name}'. Must be 'mnist' or 'fashion_mnist'.")
+
+ x_train_raw = raw_train.data.float() / 255.0 # (60000, 28, 28)
+ y_train_raw = raw_train.targets.long()
+
+ # Stratified split: 50,000 search set and 10,000 validation set
+ indices = np.arange(len(y_train_raw))
+ search_idx, val_idx = train_test_split(
+ indices,
+ train_size=50000,
+ test_size=10000,
+ stratify=y_train_raw.numpy(),
+ random_state=split_seed,
+ )
+
+ x_search_raw = x_train_raw[search_idx]
+ y_search = y_train_raw[search_idx]
+ x_val_raw = x_train_raw[val_idx]
+ y_val = y_train_raw[val_idx]
+
+ # Fit mean and std on 50k search subset ONLY
+ mean_val = float(x_search_raw.mean())
+ std_val = float(x_search_raw.std())
+
+ x_search_norm = ((x_search_raw - mean_val) / std_val).unsqueeze(1) # (50000, 1, 28, 28)
+ x_val_norm = ((x_val_raw - mean_val) / std_val).unsqueeze(1) # (10000, 1, 28, 28)
+
+ # Nested stratified subsets inside 50k search set: 2k inside 10k inside 50k
+ nested_subsets = build_nested_stratified_subsets(
+ y_search=y_search,
+ subset_sizes=[2000, 10000, 50000],
+ subset_seed=split_seed,
+ )
+
+ # Data fingerprint over search and validation splits (no test split)
+ h = hashlib.sha256()
+ for t in (x_search_norm, x_val_norm, y_search, y_val):
+ h.update(t.detach().cpu().numpy().tobytes())
+ data_fp = h.hexdigest()[:16]
+
+ split_h = hashlib.sha256()
+ split_h.update(search_idx.tobytes())
+ split_h.update(val_idx.tobytes())
+ split_fp = split_h.hexdigest()[:16]
+
+ provenance = {
+ "dataset_name": canonical_name,
+ "input_shape": [1, 28, 28],
+ "normalization_scope": "search_train_50000_only",
+ "train_mean": round(mean_val, 6),
+ "train_std": round(std_val, 6),
+ "search_samples": 50000,
+ "val_samples": 10000,
+ "test_samples": 0,
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "split_seed": split_seed,
+ "split_fingerprint": split_fp,
+ "data_fingerprint": data_fp,
+ }
+
+ return (
+ x_search_norm, y_search,
+ x_val_norm, y_val,
+ nested_subsets,
+ data_fp, provenance
+ )
+
+
+# =====================================================================
+# 3. Workload Configurations & Method Specifications
+# =====================================================================
+
+@dataclass(frozen=True)
+class WorkloadConfig:
+ workload_id: str
+ dataset_name: str
+ model_name: str
+ description: str
+
+
+WORKLOADS: Dict[str, WorkloadConfig] = {
+ "mnist_compact": WorkloadConfig(
+ workload_id="mnist_compact",
+ dataset_name="mnist",
+ model_name="compact_cnn",
+ description="MNIST dataset with CompactCNN (9,098 params control)",
+ ),
+ "mnist_wide": WorkloadConfig(
+ workload_id="mnist_wide",
+ dataset_name="mnist",
+ model_name="wide_cnn",
+ description="MNIST dataset with WideCNN (~55k params larger model axis)",
+ ),
+ "fashion_compact": WorkloadConfig(
+ workload_id="fashion_compact",
+ dataset_name="fashion_mnist",
+ model_name="compact_cnn",
+ description="FashionMNIST dataset with CompactCNN (harder data axis)",
+ ),
+ "fashion_wide": WorkloadConfig(
+ workload_id="fashion_wide",
+ dataset_name="fashion_mnist",
+ model_name="wide_cnn",
+ description="FashionMNIST dataset with WideCNN (harder data + larger model axis)",
+ ),
+}
+
+HEAVY_METHODS = ["G0", "G5", "G6", "G8"]
+
+
+def get_heavy_geometry_table() -> Dict[str, V6GeometryConfig]:
+ """Returns the subset of V6 geometry configurations used for heavy task study (G0, G5, G6, G8)."""
+ full_table = get_v6_geometry_table()
+ return {m: full_table[m] for m in HEAVY_METHODS}
+
+
+# =====================================================================
+# 4. Untrained Baseline Evaluation
+# =====================================================================
+
+def evaluate_untrained_baseline(
+ base_model: nn.Module,
+ x_sub: torch.Tensor,
+ y_sub: torch.Tensor,
+ x_val: torch.Tensor,
+ y_val: torch.Tensor,
+ device: torch.device,
+) -> Dict[str, float]:
+ """
+ Evaluates an untrained base model on validation set and objective subset
+ to establish baseline performance for feasibility classification.
+ """
+ model = copy.deepcopy(base_model).to(device)
+ val_probs = get_model_probabilities(model, x_val.to(device), device)
+ val_metrics = evaluate_probabilistic_metrics(val_probs, y_val.to(device))
+
+ # Evaluate objective subset (e.g. 2k or 10k)
+ model.eval()
+ loss_fn = nn.CrossEntropyLoss(reduction="sum")
+ x_sub_dev = x_sub.to(device)
+ y_sub_dev = y_sub.to(device)
+ num_sub = len(y_sub_dev)
+
+ with torch.inference_mode():
+ total_loss = 0.0
+ correct = 0
+ for b_start in range(0, num_sub, 1000):
+ xb = x_sub_dev[b_start:b_start + 1000]
+ yb = y_sub_dev[b_start:b_start + 1000]
+ logits = model(xb)
+ total_loss += float(loss_fn(logits, yb).item())
+ correct += int((logits.argmax(dim=1) == yb).sum().item())
+
+ obj_loss = total_loss / num_sub
+ obj_acc = (correct / num_sub) * 100.0
+
+ return {
+ "val_nll": val_metrics["nll"],
+ "val_accuracy": val_metrics["accuracy"],
+ "val_brier": val_metrics["brier"],
+ "val_ece": val_metrics["ece"],
+ "val_margin": val_metrics["margin"],
+ "objective_loss": round(obj_loss, 6),
+ "objective_accuracy": round(obj_acc, 4),
+ }
+
+
+# =====================================================================
+# 5. Method Selection & Feasibility Classification Logic
+# =====================================================================
+
+def select_best_normalized_method(
+ screen_results_for_workload: List[Dict[str, Any]]
+) -> str:
+ """
+ Selects the best normalized custom method among G0, G5, G6 for a workload
+ based on screen validation NLL ascending, with validation accuracy descending tiebreak.
+ """
+ candidates = []
+ for result in screen_results_for_workload:
+ if result["method_id"] not in ("G0", "G5", "G6"):
+ continue
+ val_loss = result.get("val_selected_loss")
+ val_acc = result.get("val_selected_acc")
+ if (
+ val_loss is not None
+ and val_acc is not None
+ and math.isfinite(val_loss)
+ and math.isfinite(val_acc)
+ ):
+ candidates.append(result)
+ if not candidates:
+ raise ValueError("No finite normalized method (G0, G5, G6) result found for selection.")
+
+ return min(
+ candidates,
+ key=lambda result: (result["val_selected_loss"], -result["val_selected_acc"]),
+ )["method_id"]
+
+
+def evaluate_feasibility(
+ confirmed_runs: List[Dict[str, Any]],
+ baseline_val_nll: float,
+ baseline_val_acc: float,
+) -> Dict[str, Any]:
+ """
+ Classifies feasibility per workload and selected method:
+ - execution_feasible: True iff every run completed with finite metrics.
+ - optimization_feasible: True iff mean validation NLL is at least 20% below baseline
+ and mean validation accuracy is at least 20 percentage points above baseline.
+ """
+ is_execution_feasible = True
+ nll_vals = []
+ acc_vals = []
+
+ for run in confirmed_runs:
+ val_nll = run.get("val_selected_loss")
+ val_acc = run.get("val_selected_acc")
+ if val_nll is None or val_acc is None:
+ is_execution_feasible = False
+ break
+ if not (math.isfinite(val_nll) and math.isfinite(val_acc)):
+ is_execution_feasible = False
+ break
+ nll_vals.append(val_nll)
+ acc_vals.append(val_acc)
+
+ target_nll_thresh = baseline_val_nll * (1.0 - FEASIBILITY_NLL_REDUCTION)
+ target_acc_thresh = baseline_val_acc + FEASIBILITY_ACCURACY_GAIN_PP
+
+ if not is_execution_feasible or len(nll_vals) == 0:
+ return {
+ "execution_feasible": False,
+ "optimization_feasible": False,
+ "baseline_val_nll": baseline_val_nll,
+ "target_val_nll_threshold": round(target_nll_thresh, 6),
+ "baseline_val_acc": baseline_val_acc,
+ "target_val_acc_threshold": round(target_acc_thresh, 4),
+ "mean_val_nll": None,
+ "mean_val_acc": None,
+ }
+
+ mean_nll = float(np.mean(nll_vals))
+ mean_acc = float(np.mean(acc_vals))
+
+ is_optimization_feasible = (mean_nll <= target_nll_thresh) and (mean_acc >= target_acc_thresh)
+
+ return {
+ "execution_feasible": True,
+ "optimization_feasible": is_optimization_feasible,
+ "baseline_val_nll": baseline_val_nll,
+ "target_val_nll_threshold": round(target_nll_thresh, 6),
+ "baseline_val_acc": baseline_val_acc,
+ "target_val_acc_threshold": round(target_acc_thresh, 4),
+ "mean_val_nll": round(mean_nll, 6),
+ "mean_val_acc": round(mean_acc, 4),
+ }
+
+
+# =====================================================================
+# 6. Screening Stage Runner (16 Workload-Method Cells)
+# =====================================================================
+
+def run_heavy_task_screen(
+ workloads: Dict[str, WorkloadConfig],
+ methods: List[str],
+ particles: int = 12,
+ epochs: int = 40,
+ seed: int = 91,
+ device: torch.device = torch.device("cpu"),
+ cache_dir: Optional[Path] = None,
+) -> Tuple[List[Dict[str, Any]], Dict[str, Dict[str, Any]], Dict[str, Any]]:
+ """
+ Screens all 16 workload-method cells at fixed 2k subset, seed 91, 12p x 40e.
+ """
+ screen_results = []
+ untrained_baselines = {}
+ data_cache = {}
+
+ geom_table = get_heavy_geometry_table()
+
+ for wl_id, wl_cfg in workloads.items():
+ if wl_cfg.dataset_name not in data_cache:
+ x_search, y_search, x_val, y_val, nested_subsets, data_fp, provenance = prepare_heavy_task_data(
+ dataset_name=wl_cfg.dataset_name,
+ cache_dir=cache_dir,
+ )
+ data_cache[wl_cfg.dataset_name] = {
+ "x_search": x_search,
+ "y_search": y_search,
+ "x_val": x_val,
+ "y_val": y_val,
+ "nested_subsets": nested_subsets,
+ "data_fp": data_fp,
+ "provenance": provenance,
+ }
+ else:
+ d = data_cache[wl_cfg.dataset_name]
+ x_search, y_search = d["x_search"], d["y_search"]
+ x_val, y_val = d["x_val"], d["y_val"]
+ nested_subsets = d["nested_subsets"]
+
+ base_model = create_model(wl_cfg.model_name, seed=41)
+ param_count = sum(p.numel() for p in base_model.parameters())
+ x_2k = x_search[nested_subsets[2000]]
+ y_2k = y_search[nested_subsets[2000]]
+
+ if wl_id not in untrained_baselines:
+ untrained_baselines[wl_id] = evaluate_untrained_baseline(
+ base_model, x_2k, y_2k, x_val, y_val, device
+ )
+
+ for m_id in methods:
+ geom_config = geom_table[m_id]
+
+ if m_id in ("G0", "G5", "G6"):
+ transform = V6LatentTransform(base_model, geom_config, device)
+ res = run_v6_pso(
+ transform=transform,
+ base_model=base_model,
+ x_search=x_search,
+ y_search=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ nested_subsets=nested_subsets,
+ schedule_str=f"2000:{epochs}",
+ epochs=epochs,
+ swarm_size=particles,
+ seed=seed,
+ device=device,
+ geom_config=geom_config,
+ val_check_interval=10,
+ )
+ # Analytical core swarm-state bytes for custom methods (Z, V, P, M, V_sq)
+ core_swarm_state_bytes = 5 * particles * param_count * 4
+ elif m_id == "G8":
+ res = run_g8_optimizer(
+ base_model=base_model,
+ x_2k=x_2k,
+ y_2k=y_2k,
+ x_val=x_val,
+ y_val=y_val,
+ epochs=epochs,
+ swarm_size=particles,
+ seed=seed,
+ device=device,
+ )
+ # Analytical core swarm-state bytes for public Optimizer (5*particles + 1 global best)
+ core_swarm_state_bytes = (5 * particles + 1) * param_count * 4
+ else:
+ raise ValueError(f"Unknown method ID: {m_id}")
+
+ opt_time = max(res["optimization_wall_time_sec"], 1e-6)
+ total_samples = res["total_sample_evaluations"]
+ throughput_sps = round(total_samples / opt_time, 2)
+
+ val_nll = res["val_selected_loss"]
+ val_acc = res["val_selected_acc"]
+ g_loss = res["gbest_loss"]
+ g_acc = res["gbest_acc"]
+
+ finite_metrics = (val_nll, val_acc, g_loss, g_acc)
+ is_finite = all(
+ val is not None and math.isfinite(val)
+ for val in finite_metrics
+ )
+
+ cell_record = {
+ "workload_id": wl_id,
+ "method_id": m_id,
+ "dataset_name": wl_cfg.dataset_name,
+ "model_name": wl_cfg.model_name,
+ "parameter_count": param_count,
+ "subset_size": 2000,
+ "particles": particles,
+ "epochs": epochs,
+ "seed": seed,
+ "gbest_loss": g_loss,
+ "gbest_acc": g_acc,
+ "gbest_val_loss": res.get("gbest_val_loss"),
+ "gbest_val_acc": res.get("gbest_val_acc"),
+ "val_selected_particle_idx": res.get("val_selected_particle_idx"),
+ "val_selected_loss": val_nll,
+ "val_selected_acc": val_acc,
+ "val_metrics": res.get("val_metrics"),
+ "wall_time_sec": res["wall_time_sec"],
+ "optimization_wall_time_sec": res["optimization_wall_time_sec"],
+ "validation_wall_time_sec": res["validation_wall_time_sec"],
+ "total_queries": res["total_queries"],
+ "total_sample_evaluations": res["total_sample_evaluations"],
+ "validation_evaluations": res["validation_evaluations"],
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": core_swarm_state_bytes,
+ "throughput_samples_per_sec": throughput_sps,
+ "is_finite": is_finite,
+ }
+ screen_results.append(cell_record)
+
+ # Workload summary metadata
+ workload_metadata = {}
+ for wl_id, wl_cfg in workloads.items():
+ bm = create_model(wl_cfg.model_name, seed=41)
+ param_count = sum(p.numel() for p in bm.parameters())
+ model_fp = compute_model_fingerprint(bm)
+ d = data_cache[wl_cfg.dataset_name]
+ workload_metadata[wl_id] = {
+ "workload_id": wl_id,
+ "dataset_name": wl_cfg.dataset_name,
+ "model_name": wl_cfg.model_name,
+ "parameter_count": param_count,
+ "model_fingerprint": model_fp,
+ "data_fingerprint": d["data_fp"],
+ "split_fingerprint": d["provenance"]["split_fingerprint"],
+ "description": wl_cfg.description,
+ }
+
+ return screen_results, untrained_baselines, workload_metadata
+
+
+# =====================================================================
+# 7. Confirmation Stage Runner (Seeds 101-103, Fixed 10k, 12p x 80e)
+# =====================================================================
+
+def run_heavy_task_confirm(
+ workloads: Dict[str, WorkloadConfig],
+ selected_methods: Dict[str, List[str]], # workload_id -> [G8, best_normalized]
+ particles: int = 12,
+ epochs: int = 80,
+ seeds: List[int] = (101, 102, 103),
+ split_seed: int = 20260902,
+ device: torch.device = torch.device("cpu"),
+ cache_dir: Optional[Path] = None,
+) -> Dict[str, Dict[str, Any]]:
+ """
+ Confirms selected methods (G8 + best normalized) for each workload at fixed 10k,
+ 12p x 80e, seeds 101-103. Aggregates mean and sample SD across seeds.
+ """
+ confirmation_results = {}
+ geom_table = get_heavy_geometry_table()
+ data_cache = {}
+
+ for wl_id, wl_cfg in workloads.items():
+ if wl_cfg.dataset_name not in data_cache:
+ x_search, y_search, x_val, y_val, nested_subsets, data_fp, provenance = prepare_heavy_task_data(
+ dataset_name=wl_cfg.dataset_name,
+ split_seed=split_seed,
+ cache_dir=cache_dir,
+ )
+ data_cache[wl_cfg.dataset_name] = {
+ "x_search": x_search,
+ "y_search": y_search,
+ "x_val": x_val,
+ "y_val": y_val,
+ "nested_subsets": nested_subsets,
+ "data_fp": data_fp,
+ "provenance": provenance,
+ }
+ else:
+ d = data_cache[wl_cfg.dataset_name]
+ x_search, y_search = d["x_search"], d["y_search"]
+ x_val, y_val = d["x_val"], d["y_val"]
+ nested_subsets = d["nested_subsets"]
+ data_fp = d["data_fp"]
+ provenance = d["provenance"]
+
+ base_model = create_model(wl_cfg.model_name, seed=41)
+ param_count = sum(p.numel() for p in base_model.parameters())
+ x_10k = x_search[nested_subsets[10000]]
+ y_10k = y_search[nested_subsets[10000]]
+
+ wl_confirmations = {}
+ methods_to_confirm = selected_methods[wl_id]
+
+ for m_id in methods_to_confirm:
+ geom_config = geom_table[m_id]
+ per_seed_runs = []
+
+ for s in seeds:
+ if m_id in ("G0", "G5", "G6"):
+ transform = V6LatentTransform(base_model, geom_config, device)
+ res = run_v6_pso(
+ transform=transform,
+ base_model=base_model,
+ x_search=x_search,
+ y_search=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ nested_subsets=nested_subsets,
+ schedule_str=f"10000:{epochs}",
+ epochs=epochs,
+ swarm_size=particles,
+ seed=s,
+ device=device,
+ geom_config=geom_config,
+ val_check_interval=10,
+ )
+ core_bytes = 5 * particles * param_count * 4
+ elif m_id == "G8":
+ res = run_g8_optimizer(
+ base_model=base_model,
+ x_2k=x_10k, # Passes 10k search tensor for 10k fit
+ y_2k=y_10k,
+ x_val=x_val,
+ y_val=y_val,
+ epochs=epochs,
+ swarm_size=particles,
+ seed=s,
+ device=device,
+ )
+ core_bytes = (5 * particles + 1) * param_count * 4
+ else:
+ raise ValueError(f"Unknown method ID: {m_id}")
+
+ opt_time = max(res["optimization_wall_time_sec"], 1e-6)
+ sps = round(res["total_sample_evaluations"] / opt_time, 2)
+
+ seed_record = {
+ "seed": s,
+ "val_selected_loss": res["val_selected_loss"],
+ "val_selected_acc": res["val_selected_acc"],
+ "val_metrics": res.get("val_metrics"),
+ "gbest_loss": res["gbest_loss"],
+ "gbest_acc": res["gbest_acc"],
+ "wall_time_sec": res["wall_time_sec"],
+ "optimization_wall_time_sec": res["optimization_wall_time_sec"],
+ "validation_wall_time_sec": res["validation_wall_time_sec"],
+ "total_queries": res["total_queries"],
+ "total_sample_evaluations": res["total_sample_evaluations"],
+ "validation_evaluations": res["validation_evaluations"],
+ "official_test_evaluations": 0,
+ "core_swarm_state_bytes": core_bytes,
+ "throughput_samples_per_sec": sps,
+ }
+ per_seed_runs.append(seed_record)
+
+ # Compute aggregated mean & sample SD stats
+ acc_list = [r["val_selected_acc"] for r in per_seed_runs]
+ nll_list = [r["val_selected_loss"] for r in per_seed_runs]
+ brier_list = [r["val_metrics"]["brier"] for r in per_seed_runs if r.get("val_metrics")]
+ ece_list = [r["val_metrics"]["ece"] for r in per_seed_runs if r.get("val_metrics")]
+ g_loss_list = [r["gbest_loss"] for r in per_seed_runs]
+ g_acc_list = [r["gbest_acc"] for r in per_seed_runs]
+ wall_list = [r["wall_time_sec"] for r in per_seed_runs]
+ opt_wall_list = [r["optimization_wall_time_sec"] for r in per_seed_runs]
+ sps_list = [r["throughput_samples_per_sec"] for r in per_seed_runs]
+
+ stats = {
+ "val_acc": calc_stats(acc_list),
+ "val_nll": calc_stats(nll_list),
+ "val_brier": calc_stats(brier_list) if brier_list else None,
+ "val_ece": calc_stats(ece_list) if ece_list else None,
+ "gbest_loss": calc_stats(g_loss_list),
+ "gbest_acc": calc_stats(g_acc_list),
+ "wall_time_sec": calc_stats(wall_list),
+ "optimization_wall_time_sec": calc_stats(opt_wall_list),
+ "throughput_samples_per_sec": calc_stats(sps_list),
+ }
+
+ wl_confirmations[m_id] = {
+ "workload_id": wl_id,
+ "method_id": m_id,
+ "subset_size": 10000,
+ "particles": particles,
+ "epochs": epochs,
+ "seeds": list(seeds),
+ "split_seed": split_seed,
+ "data_fingerprint": data_fp,
+ "split_fingerprint": provenance["split_fingerprint"],
+ "provenance": provenance,
+ "stats": stats,
+ "per_seed_runs": per_seed_runs,
+ }
+
+ confirmation_results[wl_id] = wl_confirmations
+
+ return confirmation_results
+
+
+# =====================================================================
+# 8. CSV & Plot Artifact Generators
+# =====================================================================
+
+def save_csv_summary(payload: Dict[str, Any], csv_path: Path):
+ """Saves a clean, concise CSV summary of screen, confirmation, and feasibility results."""
+ csv_path.parent.mkdir(parents=True, exist_ok=True)
+ with open(csv_path, "w", newline="", encoding="utf-8") as f:
+ writer = csv.writer(f)
+ writer.writerow(["section", "workload", "method", "metric", "value"])
+ writer.writerow(["protocol", "global", "all", "version", payload["protocol_version"]])
+ writer.writerow(["protocol", "global", "all", "official_test_data_loaded", payload["official_test_data_loaded"]])
+ writer.writerow(["protocol", "global", "all", "official_test_evaluations", payload["official_test_evaluations"]])
+
+ # Untrained Baselines
+ baselines = payload.get("untrained_baselines", {})
+ for wl_id, base in baselines.items():
+ writer.writerow(["baseline", wl_id, "untrained", "val_nll", base["val_nll"]])
+ writer.writerow(["baseline", wl_id, "untrained", "val_accuracy", base["val_accuracy"]])
+
+ # Screen Results
+ screen_res = payload.get("screen_results", [])
+ for r in screen_res:
+ wl = r["workload_id"]
+ m = r["method_id"]
+ writer.writerow(["screen", wl, m, "val_nll", r["val_selected_loss"]])
+ writer.writerow(["screen", wl, m, "val_acc", r["val_selected_acc"]])
+ writer.writerow(["screen", wl, m, "gbest_loss", r["gbest_loss"]])
+ writer.writerow(["screen", wl, m, "gbest_acc", r["gbest_acc"]])
+ writer.writerow(["screen", wl, m, "throughput_sps", r["throughput_samples_per_sec"]])
+
+ # Confirmation Results
+ confirm_res = payload.get("confirmation_results", {})
+ for wl_id, m_dict in confirm_res.items():
+ for m_id, conf in m_dict.items():
+ st = conf["stats"]
+ writer.writerow(["confirm", wl_id, m_id, "val_acc_mean", st["val_acc"]["mean"]])
+ writer.writerow(["confirm", wl_id, m_id, "val_acc_std", st["val_acc"]["std"]])
+ writer.writerow(["confirm", wl_id, m_id, "val_nll_mean", st["val_nll"]["mean"]])
+ writer.writerow(["confirm", wl_id, m_id, "val_nll_std", st["val_nll"]["std"]])
+ writer.writerow(["confirm", wl_id, m_id, "wall_time_sec_mean", st["wall_time_sec"]["mean"]])
+
+ # Feasibility Evaluations
+ feas_evals = payload.get("feasibility_evaluations", {})
+ for wl_id, m_feas in feas_evals.items():
+ for m_id, fe in m_feas.items():
+ writer.writerow(["feasibility", wl_id, m_id, "execution_feasible", fe["execution_feasible"]])
+ writer.writerow(["feasibility", wl_id, m_id, "optimization_feasible", fe["optimization_feasible"]])
+ writer.writerow(["feasibility", wl_id, m_id, "mean_val_nll", fe["mean_val_nll"]])
+ writer.writerow(["feasibility", wl_id, m_id, "mean_val_acc", fe["mean_val_acc"]])
+
+
+def generate_feasibility_plot(payload: Dict[str, Any], plot_path: Path):
+ """
+ Generates a clear two-panel visualization:
+ Panel 1: Validation NLL screen comparison across all 16 workload-method cells.
+ Panel 2: Confirmation Accuracy vs Parameter Count for each workload,
+ distinguishing dataset (MNIST vs FashionMNIST), model size, and method.
+ """
+ plot_path.parent.mkdir(parents=True, exist_ok=True)
+
+ fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15.5, 6))
+
+ # Panel 1: Screen Validation NLL
+ screen_results = payload.get("screen_results", [])
+ workload_order = ["mnist_compact", "mnist_wide", "fashion_compact", "fashion_wide"]
+ method_order = ["G0", "G5", "G6", "G8"]
+
+ cell_dict = {(r["workload_id"], r["method_id"]): r["val_selected_loss"] for r in screen_results}
+
+ x_indices = np.arange(len(workload_order))
+ width = 0.18
+ colors = {"G0": "#1f77b4", "G5": "#ff7f0e", "G6": "#2ca02c", "G8": "#d62728"}
+
+ for idx, m_id in enumerate(method_order):
+ vals = [cell_dict.get((wl_id, m_id), 0.0) for wl_id in workload_order]
+ ax1.bar(x_indices + (idx - 1.5) * width, vals, width, label=m_id, color=colors[m_id])
+
+ ax1.set_xticks(x_indices)
+ ax1.set_xticklabels(["MNIST\nCompact", "MNIST\nWide", "Fashion\nCompact", "Fashion\nWide"], fontsize=9)
+ ax1.set_ylabel("Validation NLL (Screen fixed2k, lower is better)")
+ ax1.set_title("Screening Stage: Validation NLL (16 Cells)")
+ ax1.legend(title="Method")
+ ax1.grid(True, linestyle="--", alpha=0.5)
+
+ # Panel 2: Confirmation Accuracy vs Parameter Count
+ confirm_results = payload.get("confirmation_results", {})
+ workload_info = payload.get("workloads", {})
+
+ markers = {"mnist": "o", "fashion_mnist": "s"}
+ dataset_x_factors = {"mnist": 0.94, "fashion_mnist": 1.06}
+ method_x_factors = {"G8": 0.985, "G0": 1.015, "G5": 1.015, "G6": 1.015}
+
+ parameter_counts = sorted({
+ metadata["parameter_count"]
+ for metadata in workload_info.values()
+ })
+ for parameter_count in parameter_counts:
+ ax2.axvline(parameter_count, color="#bbbbbb", linewidth=0.8, linestyle=":")
+
+ for wl_id, m_dict in confirm_results.items():
+ wl_meta = workload_info.get(wl_id, {})
+ ds_name = wl_meta.get("dataset_name", "mnist").lower()
+ param_count = wl_meta.get("parameter_count", 9098)
+ marker = markers.get(ds_name, "o")
+
+ for m_id, conf in m_dict.items():
+ acc_mean = conf["stats"]["val_acc"]["mean"]
+ acc_std = conf["stats"]["val_acc"]["std"]
+ color = colors.get(m_id, "#333333")
+ display_x = (
+ param_count
+ * dataset_x_factors.get(ds_name, 1.0)
+ * method_x_factors.get(m_id, 1.0)
+ )
+
+ ax2.errorbar(
+ [display_x],
+ [acc_mean],
+ yerr=[acc_std],
+ fmt=marker,
+ color=color,
+ linestyle="none",
+ capsize=5,
+ markersize=8,
+ label="_nolegend_",
+ )
+
+ ax2.set_xlabel("Model Parameter Count D (log scale; points horizontally offset)")
+ ax2.set_ylabel("Validation Accuracy % (Confirmation fixed10k, mean ± SD)")
+ ax2.set_title("Confirmation: G8 + Screen-Selected Normalized Method")
+ ax2.set_xticks(parameter_counts)
+ ax2.set_xticklabels([f"{count:,}" for count in parameter_counts])
+ ax2.grid(True, axis="y", linestyle="--", alpha=0.5)
+ ax2.set_xscale("log")
+ dataset_handles = [
+ Line2D(
+ [0],
+ [0],
+ marker=marker,
+ color="#333333",
+ linestyle="none",
+ markersize=8,
+ label=label,
+ )
+ for label, marker in (("MNIST", "o"), ("FashionMNIST", "s"))
+ ]
+ confirmed_method_ids = sorted({
+ method_id
+ for methods in confirm_results.values()
+ for method_id in methods
+ })
+ method_handles = [
+ Line2D(
+ [0],
+ [0],
+ marker="o",
+ color=colors[method_id],
+ linestyle="none",
+ markersize=8,
+ label=method_id,
+ )
+ for method_id in confirmed_method_ids
+ ]
+ dataset_legend = ax2.legend(
+ handles=dataset_handles,
+ title="Dataset marker",
+ fontsize=8,
+ loc="upper left",
+ bbox_to_anchor=(1.01, 1.0),
+ )
+ ax2.add_artist(dataset_legend)
+ ax2.legend(
+ handles=method_handles,
+ title="Method color",
+ fontsize=8,
+ loc="upper left",
+ bbox_to_anchor=(1.01, 0.68),
+ )
+
+ plt.tight_layout()
+ plt.savefig(plot_path, dpi=150)
+ plt.close(fig)
+
+
+# =====================================================================
+# 9. Main Orchestration Runner & CLI Entrypoint
+# =====================================================================
+
+def run_heavy_task_study(args: argparse.Namespace) -> Dict[str, Any]:
+ """Orchestrates screen, confirmation, feasibility evaluation, and artifact generation."""
+ start_time_all = time.time()
+ device = resolve_execution_device(args.device)
+
+ cache_dir = Path(args.cache_dir)
+ out_dir = Path(args.out_dir)
+ plot_dir = Path(args.plot_dir)
+
+ out_dir.mkdir(parents=True, exist_ok=True)
+ plot_dir.mkdir(parents=True, exist_ok=True)
+
+ screen_particles = args.screen_particles
+ screen_epochs = args.screen_epochs
+ screen_seed = args.screen_seeds[0] if args.screen_seeds else 91
+
+ confirm_particles = args.confirm_particles
+ confirm_epochs = args.confirm_epochs
+ confirm_seeds = args.confirm_seeds
+ screen_design = {
+ "methods": list(HEAVY_METHODS),
+ "subset_size": 2000,
+ "particles": screen_particles,
+ "epochs": screen_epochs,
+ "seed": screen_seed,
+ "cells": len(WORKLOADS) * len(HEAVY_METHODS),
+ }
+ method_configs = {
+ method_id: asdict(config)
+ for method_id, config in get_heavy_geometry_table().items()
+ }
+
+
+ screen_results = []
+ untrained_baselines = {}
+ workload_metadata = {}
+ normalized_selections = {}
+
+ if args.stage in ("screen", "all"):
+ print(f"[{PROTOCOL_VERSION}] Starting Screening Stage (16 Cells at fixed2k, {screen_particles}p x {screen_epochs}e, seed {screen_seed})...")
+ screen_results, untrained_baselines, workload_metadata = run_heavy_task_screen(
+ workloads=WORKLOADS,
+ methods=HEAVY_METHODS,
+ particles=screen_particles,
+ epochs=screen_epochs,
+ seed=screen_seed,
+ device=device,
+ cache_dir=cache_dir,
+ )
+
+ # Select best normalized method for each workload
+ for wl_id in WORKLOADS:
+ wl_screen = [r for r in screen_results if r["workload_id"] == wl_id]
+ best_norm = select_best_normalized_method(wl_screen)
+ normalized_selections[wl_id] = best_norm
+ print(f" Workload '{wl_id}': G8 + selected best normalized method '{best_norm}'")
+
+ if args.stage == "screen":
+ # Save screen-only artifact
+ screen_payload = {
+ "protocol_version": PROTOCOL_VERSION,
+ "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+ "hardware": get_hardware_provenance(device),
+ "pso_version": pso_version,
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "study_design": {
+ "screen": screen_design,
+ "selection": {
+ "candidates": ["G0", "G5", "G6"],
+ "ranking": ["validation_nll_ascending", "validation_accuracy_descending"],
+ "confirmation_reference": "G8",
+ },
+ "validation": {
+ "source": "official_training_split_only",
+ "split": "50000_search_10000_validation_stratified",
+ "split_seed": 20260902,
+ },
+ },
+ "method_configs": method_configs,
+ "workloads": workload_metadata,
+ "untrained_baselines": untrained_baselines,
+ "screen_results": screen_results,
+ "normalized_method_selections": normalized_selections,
+ }
+ save_json_atomic(screen_payload, out_dir / "pso_v6_heavy_tasks_screen.json")
+ print(f"Screening complete. Saved to {out_dir / 'pso_v6_heavy_tasks_screen.json'}")
+ return screen_payload
+
+ elif args.stage == "confirm":
+ screen_artifact_path = args.screen_artifact or (out_dir / "pso_v6_heavy_tasks_screen.json")
+ if not screen_artifact_path.exists():
+ screen_artifact_path = out_dir / "pso_v6_heavy_tasks.json"
+ if not screen_artifact_path.exists():
+ raise FileNotFoundError(f"Screen artifact not found at {screen_artifact_path}. Run --stage screen or --stage all first.")
+
+ with open(screen_artifact_path, "r", encoding="utf-8") as f:
+ screen_payload = json.load(f)
+
+ screen_results = screen_payload["screen_results"]
+ untrained_baselines = screen_payload["untrained_baselines"]
+ workload_metadata = screen_payload["workloads"]
+ normalized_selections = screen_payload["normalized_method_selections"]
+ screen_design = screen_payload["study_design"]["screen"]
+
+
+ # Confirmation Stage
+ selected_methods_to_confirm = {}
+ for wl_id in WORKLOADS:
+ best_norm = normalized_selections[wl_id]
+ selected_methods_to_confirm[wl_id] = ["G8", best_norm]
+
+ print(f"[{PROTOCOL_VERSION}] Starting Confirmation Stage (Seeds {confirm_seeds}, fixed10k, {confirm_particles}p x {confirm_epochs}e)...")
+ confirm_results = run_heavy_task_confirm(
+ workloads=WORKLOADS,
+ selected_methods=selected_methods_to_confirm,
+ particles=confirm_particles,
+ epochs=confirm_epochs,
+ seeds=confirm_seeds,
+ device=device,
+ cache_dir=cache_dir,
+ )
+
+ # Feasibility Evaluations
+ feasibility_evals = {}
+ for wl_id, m_dict in confirm_results.items():
+ base = untrained_baselines[wl_id]
+ wl_feas = {}
+ for m_id, conf in m_dict.items():
+ feas = evaluate_feasibility(
+ confirmed_runs=conf["per_seed_runs"],
+ baseline_val_nll=base["val_nll"],
+ baseline_val_acc=base["val_accuracy"],
+ )
+ wl_feas[m_id] = feas
+ feasibility_evals[wl_id] = wl_feas
+
+ # Aggregate Resource Totals
+ tot_queries = 0
+ tot_samples = 0
+ tot_opt_wall = 0.0
+ tot_val_wall = 0.0
+ tot_run_wall = 0.0
+
+ for r in screen_results:
+ tot_queries += r["total_queries"]
+ tot_samples += r["total_sample_evaluations"]
+ tot_opt_wall += r["optimization_wall_time_sec"]
+ tot_val_wall += r["validation_wall_time_sec"]
+ tot_run_wall += r["wall_time_sec"]
+
+ for wl_id, m_dict in confirm_results.items():
+ for m_id, conf in m_dict.items():
+ for run in conf["per_seed_runs"]:
+ tot_queries += run["total_queries"]
+ tot_samples += run["total_sample_evaluations"]
+ tot_opt_wall += run["optimization_wall_time_sec"]
+ tot_val_wall += run["validation_wall_time_sec"]
+ tot_run_wall += run["wall_time_sec"]
+
+ resource_totals = {
+ "total_queries": tot_queries,
+ "total_sample_evaluations": tot_samples,
+ "summed_optimization_wall_time_sec": round(tot_opt_wall, 4),
+ "summed_validation_wall_time_sec": round(tot_val_wall, 4),
+ "summed_recorded_run_wall_time_sec": round(tot_run_wall, 4),
+ "elapsed_current_process_wall_time_sec": round(time.time() - start_time_all, 4),
+ }
+
+ final_payload = {
+ "protocol_version": PROTOCOL_VERSION,
+ "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+ "hardware": get_hardware_provenance(device),
+ "pso_version": pso_version,
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "study_design": {
+ "screen": screen_design,
+ "confirmation": {
+ "methods_per_workload": selected_methods_to_confirm,
+ "subset_size": 10000,
+ "particles": confirm_particles,
+ "epochs": confirm_epochs,
+ "seeds": list(confirm_seeds),
+ },
+ "selection": {
+ "candidates": ["G0", "G5", "G6"],
+ "ranking": ["validation_nll_ascending", "validation_accuracy_descending"],
+ "confirmation_reference": "G8",
+ },
+ "feasibility_contract": {
+ "execution": "all_confirmed_runs_complete_with_finite_metrics",
+ "minimum_validation_nll_reduction_fraction": FEASIBILITY_NLL_REDUCTION,
+ "minimum_validation_accuracy_gain_percentage_points": FEASIBILITY_ACCURACY_GAIN_PP,
+ "requires_both_optimization_thresholds": True,
+ },
+ "validation": {
+ "source": "official_training_split_only",
+ "split": "50000_search_10000_validation_stratified",
+ "split_seed": 20260902,
+ "official_test_split_used": False,
+ },
+ },
+ "method_configs": method_configs,
+ "workloads": workload_metadata,
+ "untrained_baselines": untrained_baselines,
+ "screen_results": screen_results,
+ "normalized_method_selections": normalized_selections,
+ "confirmation_results": confirm_results,
+ "feasibility_evaluations": feasibility_evals,
+ "resource_totals": resource_totals,
+ }
+
+ # Persist JSON, CSV, and plot
+ json_path = out_dir / "pso_v6_heavy_tasks.json"
+ csv_path = out_dir / "pso_v6_heavy_tasks.csv"
+ plot_path = plot_dir / "pso_v6_heavy_tasks.png"
+
+ save_json_atomic(final_payload, json_path)
+ save_csv_summary(final_payload, csv_path)
+ generate_feasibility_plot(final_payload, plot_path)
+
+ print(f"[{PROTOCOL_VERSION}] Study complete!")
+ print(f" JSON: {json_path}")
+ print(f" CSV: {csv_path}")
+ print(f" Plot: {plot_path}")
+
+ return final_payload
+
+
+def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(description="MNIST / FashionMNIST PSO Heavy Task Feasibility Study")
+ parser.add_argument("--stage", choices=["screen", "confirm", "all"], default="all", help="Study stage to run")
+ parser.add_argument("--device", type=str, default=None, help="Device (cpu, mps, cuda)")
+ parser.add_argument("--screen-particles", type=int, default=12, help="Screening particle count")
+ parser.add_argument("--screen-epochs", type=int, default=40, help="Screening epoch count")
+ parser.add_argument("--confirm-particles", type=int, default=12, help="Confirmation particle count")
+ parser.add_argument("--confirm-epochs", type=int, default=80, help="Confirmation epoch count")
+ parser.add_argument("--screen-seeds", type=int, nargs="+", default=[91], help="Screening seed")
+ parser.add_argument("--confirm-seeds", type=int, nargs="+", default=[101, 102, 103], help="Confirmation seeds")
+ parser.add_argument("--cache-dir", type=str, default="result/cache", help="Data cache directory")
+ parser.add_argument("--out-dir", type=str, default="benchmark_results", help="Output directory")
+ parser.add_argument("--plot-dir", type=str, default="history_plt", help="Plot directory")
+ parser.add_argument("--screen-artifact", type=Path, default=None, help="Screen JSON artifact for confirm-only stage")
+ return parser
+
+
+def main():
+ parser = build_parser()
+ args = parser.parse_args()
+ run_heavy_task_study(args)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/iris.py b/test/iris.py
index e0e8cf7..fd0a36c 100644
--- a/test/iris.py
+++ b/test/iris.py
@@ -1,73 +1,111 @@
-import gc
-import os
-import sys
-
+import argparse
+import torch
+import torch.nn as nn
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
-from tensorflow import keras
-from tensorflow.keras import layers
-from tensorflow.keras.models import Sequential
+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 make_model():
- model = Sequential()
- model.add(layers.Dense(10, activation="relu", input_shape=(4,)))
- model.add(layers.Dense(10, activation="relu"))
- model.add(layers.Dense(3, activation="softmax"))
-
- return model
-
-
-def load_data():
- iris = load_iris()
- x = iris.data
- y = iris.target
-
- y = keras.utils.to_categorical(y, 3)
-
- x_train, x_test, y_train, y_test = train_test_split(
- x, y, test_size=0.2, shuffle=True, stratify=y
+def make_model(seed: int = 42):
+ torch.manual_seed(seed)
+ return nn.Sequential(
+ nn.Linear(4, 10),
+ nn.ReLU(),
+ nn.Linear(10, 10),
+ nn.ReLU(),
+ nn.Linear(10, 3),
)
- return x_train, x_test, y_train, y_test
+
+def load_data(seed: int = 42):
+ iris = load_iris()
+ x = iris.data.astype("float32")
+ y = iris.target.astype("int64")
+
+ x_train, x_test, y_train, y_test = train_test_split(
+ x, y, test_size=0.2, shuffle=True, stratify=y, 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(x_test, dtype=torch.float32),
+ torch.tensor(y_train, dtype=torch.int64),
+ torch.tensor(y_test, dtype=torch.int64),
+ )
-model = make_model()
-x_train, x_test, y_train, y_test = load_data()
+def main():
+ parser = argparse.ArgumentParser(description="PSO Iris 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.1,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "velocity_limit_ratio": 0.1,
+ "boundary_strategy": "reflect",
+ "seed": 42,
+ "epochs": 70,
+ "renewal": "loss",
+ "output_dir": "output/iris",
+ "checkpoint_interval": 25,
+ "refinement_epochs": 10,
+ "refinement_lr": 0.001,
+ },
+ )
+ args = parser.parse_args()
+
+ model = make_model(seed=args.seed)
+ x_train, x_test, y_train, y_test = load_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": 0.3, "w_min": 0.1, "w_max": 0.9},
+ )
+ pso_iris = Optimizer(**kwargs)
+
+ print(f"Optimizer device: {pso_iris.device}")
+
+ best_score = pso_iris.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}")
-pso_iris = optimizer(
- model=model,
- loss="categorical_crossentropy",
- n_particles=100,
- c0=0.5,
- c1=0.3,
- w_min=0.1,
- w_max=0.9,
- negative_swarm=0,
- mutation_swarm=0.1,
- convergence_reset=True,
- convergence_reset_patience=10,
- convergence_reset_monitor="loss",
- convergence_reset_min_delta=0.001,
-)
-
-best_score = pso_iris.fit(
- x_train,
- y_train,
- epochs=500,
- save_info=True,
- log=2,
- log_name="iris",
- renewal="loss",
- check_point=25,
- validate_data=(x_test, y_test),
-)
-
-gc.collect()
-print("Done!")
-sys.exit(0)
+if __name__ == "__main__":
+ main()
diff --git a/test/iris_tf.py b/test/iris_tf.py
deleted file mode 100644
index 828bdf7..0000000
--- a/test/iris_tf.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import os
-
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
-
-import tensorflow as tf
-
-gpus = tf.config.experimental.list_physical_devices("GPU")
-if gpus:
- try:
- # tf.config.experimental.set_visible_devices(gpus[0], "GPU")
- tf.config.experimental.set_memory_growth(gpus[0], True)
- except RuntimeError as e:
- print(e)
-
-from sklearn.datasets import load_iris
-from sklearn.model_selection import train_test_split
-from tensorflow import keras
-from tensorflow.keras import layers
-from tensorflow.keras.models import Sequential
-
-
-def make_model():
- model = Sequential()
- model.add(layers.Dense(10, activation="relu", input_shape=(4,)))
- model.add(layers.Dense(10, activation="relu"))
- model.add(layers.Dense(3, activation="softmax"))
-
- return model
-
-
-def load_data():
- iris = load_iris()
- x = iris.data
- y = iris.target
-
- y = keras.utils.to_categorical(y, 3)
-
- x_train, x_test, y_train, y_test = train_test_split(
- x, y, test_size=0.2, shuffle=True, stratify=y
- )
-
- return x_train, x_test, y_train, y_test
-
-
-if __name__ == "__main__":
- model = make_model()
- x_train, x_test, y_train, y_test = load_data()
- print(x_train.shape, y_train.shape)
-
- loss = ["categorical_crossentropy", "accuracy", "mse"]
- metrics = ["accuracy"]
-
- model.compile(optimizer="sgd", loss=loss[0], metrics=metrics[0])
- model.fit(x_train, y_train, epochs=200, batch_size=32, validation_split=0.2)
- model.evaluate(x_test, y_test, batch_size=32)
diff --git a/test/iris_torch.py b/test/iris_torch.py
new file mode 100644
index 0000000..7d9bc4d
--- /dev/null
+++ b/test/iris_torch.py
@@ -0,0 +1,127 @@
+"""Iris dataset gradient baseline (PyTorch standard backprop optimizer, non-PSO)."""
+
+import copy
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+
+
+class IrisModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.net = nn.Sequential(
+ nn.Linear(4, 10),
+ nn.ReLU(),
+ nn.Linear(10, 10),
+ nn.ReLU(),
+ nn.Linear(10, 3),
+ )
+
+ def forward(self, x):
+ return self.net(x)
+
+
+def load_data(seed: int = 42):
+ iris = load_iris()
+ X = iris.data.astype("float32")
+ y = iris.target.astype("int64")
+
+ x_train, x_test, y_train, y_test = train_test_split(
+ X, y, test_size=0.2, shuffle=True, stratify=y, random_state=seed
+ )
+ return (
+ torch.tensor(x_train, dtype=torch.float32),
+ torch.tensor(x_test, dtype=torch.float32),
+ torch.tensor(y_train, dtype=torch.int64),
+ torch.tensor(y_test, dtype=torch.int64),
+ )
+
+
+def get_device() -> torch.device:
+ if (
+ hasattr(torch.backends, "mps")
+ and torch.backends.mps.is_built()
+ and torch.backends.mps.is_available()
+ ):
+ return torch.device("mps")
+ elif torch.cuda.is_available():
+ return torch.device("cuda")
+ return torch.device("cpu")
+
+
+def main():
+ torch.manual_seed(42)
+ np.random.seed(42)
+
+ device = get_device()
+ print(f"Selected device: {device}")
+
+ x_train, x_test, y_train, y_test = load_data(seed=42)
+ train_loader = DataLoader(
+ TensorDataset(x_train, y_train), batch_size=32, shuffle=True
+ )
+ val_loader = DataLoader(
+ TensorDataset(x_test, y_test), batch_size=32, shuffle=False
+ )
+
+ model = IrisModel().to(device)
+ optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
+ criterion = nn.CrossEntropyLoss()
+
+ best_val_loss = float("inf")
+ best_state = None
+
+ for epoch in range(200):
+ model.train()
+ for bx, by in train_loader:
+ bx, by = bx.to(device), by.to(device)
+ optimizer.zero_grad()
+ out = model(bx)
+ loss = criterion(out, by)
+ loss.backward()
+ optimizer.step()
+
+ model.eval()
+ val_loss = 0.0
+ total = 0
+ with torch.no_grad():
+ for bx, by in val_loader:
+ bx, by = bx.to(device), by.to(device)
+ out = model(bx)
+ loss = criterion(out, by)
+ val_loss += loss.item() * bx.size(0)
+ total += bx.size(0)
+
+ val_loss /= total
+
+ if val_loss < best_val_loss:
+ best_val_loss = val_loss
+ best_state = copy.deepcopy(model.state_dict())
+
+ if best_state is not None:
+ model.load_state_dict(best_state)
+
+ model.eval()
+ test_loss = 0.0
+ correct = 0
+ total = 0
+ with torch.no_grad():
+ for bx, by in val_loader:
+ bx, by = bx.to(device), by.to(device)
+ out = model(bx)
+ loss = criterion(out, by)
+ test_loss += loss.item() * bx.size(0)
+ preds = out.argmax(dim=1)
+ correct += (preds == by).sum().item()
+ total += bx.size(0)
+
+ test_loss /= total
+ test_acc = correct / total
+ print(f"Final test loss: {test_loss:.4f}, accuracy: {test_acc:.4f}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/mnist.py b/test/mnist.py
index 415e2a0..bd3f677 100644
--- a/test/mnist.py
+++ b/test/mnist.py
@@ -1,88 +1,111 @@
-# %%
-import os
-import sys
+import argparse
+import torch
+import torch.nn as nn
-from pso import optimizer
-
-import tensorflow as tf
-from keras.datasets import mnist
-from keras.layers import Conv2D, Dense, Dropout, Flatten, MaxPooling2D
-from keras.models import Sequential
+from pso import Optimizer
+from cli import add_pso_args, build_optimizer_kwargs
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+def get_data(seed: int = 42):
+ from sklearn.decomposition import PCA
+ from torchvision.datasets import MNIST
+ train_dataset = MNIST(root="./data", train=True, download=True)
+ test_dataset = MNIST(root="./data", train=False, download=True)
-def get_data():
- (x_train, y_train), (x_test, y_test) = mnist.load_data()
+ x_train_raw = (train_dataset.data[:3000].float() / 255.0).reshape(3000, -1).numpy()
+ y_train = train_dataset.targets[:3000].long()
- x_train, x_test = x_train / 255.0, x_test / 255.0
- x_train = x_train.reshape((60000, 28, 28, 1))
- x_test = x_test.reshape((10000, 28, 28, 1))
+ x_test_raw = (test_dataset.data[:1000].float() / 255.0).reshape(1000, -1).numpy()
+ y_test = test_dataset.targets[:1000].long()
- y_train, y_test = tf.one_hot(y_train, 10), tf.one_hot(y_test, 10)
+ pca = PCA(n_components=32, whiten=True, random_state=seed)
+ x_train_pca = pca.fit_transform(x_train_raw)
+ x_test_pca = pca.transform(x_test_raw)
- x_train, x_test = tf.convert_to_tensor(x_train), tf.convert_to_tensor(x_test)
- y_train, y_test = tf.convert_to_tensor(y_train), tf.convert_to_tensor(y_test)
+ x_train = torch.tensor(x_train_pca, dtype=torch.float32)
+ x_test = torch.tensor(x_test_pca, dtype=torch.float32)
- print(f"x_train : {x_train[0].shape} | y_train : {y_train[0].shape}")
- print(f"x_test : {x_test[0].shape} | y_test : {y_test[0].shape}")
+ print(f"x_train : {x_train.shape} | y_train : {y_train.shape}")
+ print(f"x_test : {x_test.shape} | y_test : {y_test.shape}")
return x_train, y_train, x_test, y_test
-def make_model():
- model = Sequential()
- model.add(
- Conv2D(32, kernel_size=(5, 5), activation="relu", input_shape=(28, 28, 1))
+def make_model(seed: int = 42):
+ torch.manual_seed(seed)
+ return nn.Linear(32, 10)
+
+
+def main():
+ parser = argparse.ArgumentParser(description="PSO MNIST Benchmark Script")
+ add_pso_args(
+ parser,
+ defaults={
+ "method": "inertia",
+ "initialization": "model_noise",
+ "evaluation": "fixed_subset",
+ "convergence": "none",
+ "refinement": "adam",
+ "n_particles": 30,
+ "c0": None,
+ "c1": None,
+ "w_min": None,
+ "w_max": None,
+ "negative_swarm": 0.0,
+ "mutation_swarm": 0.02,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "velocity_limit_ratio": 0.025,
+ "boundary_strategy": "reflect",
+ "initial_position_noise": 0.05,
+ "seed": 42,
+ "epochs": 80,
+ "batch_size": 1000,
+ "fitness_size": 2000,
+ "renewal": "loss",
+ "output_dir": "output/mnist",
+ "checkpoint_interval": 25,
+ "refinement_epochs": 100,
+ "refinement_lr": 0.01,
+ },
)
- model.add(MaxPooling2D(pool_size=(2, 2)))
- model.add(Dropout(0.5))
- model.add(Conv2D(64, kernel_size=(3, 3), activation="relu"))
- model.add(MaxPooling2D(pool_size=(2, 2)))
- model.add(Flatten())
- model.add(Dropout(0.5))
- model.add(Dense(256, activation="relu"))
- model.add(Dense(128, activation="relu"))
- model.add(Dense(10, activation="softmax"))
+ 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": 1.49618, "c1": 1.49618, "w_min": 0.7298, "w_max": 0.7298},
+ )
+ pso_mnist = Optimizer(**kwargs)
+
+ print(f"Optimizer device: {pso_mnist.device}")
+
+ best_score = pso_mnist.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()
-
-
-pso_mnist = optimizer(
- model,
- loss="categorical_crossentropy",
- n_particles=200,
- c0=0.7,
- c1=0.4,
- w_min=0.1,
- w_max=0.9,
- negative_swarm=0.0,
- mutation_swarm=0.05,
- convergence_reset=True,
- convergence_reset_patience=10,
- convergence_reset_monitor="loss",
- convergence_reset_min_delta=0.005,
-)
-
-best_score = pso_mnist.fit(
- x_train,
- y_train,
- epochs=1000,
- save_info=True,
- log=2,
- log_name="mnist",
- renewal="loss",
- check_point=25,
- batch_size=5000,
- validate_data=(x_test, y_test),
-)
-
-print("Done!")
-
-sys.exit(0)
+if __name__ == "__main__":
+ main()
diff --git a/test/mnist_tf.py b/test/mnist_tf.py
deleted file mode 100644
index e153d46..0000000
--- a/test/mnist_tf.py
+++ /dev/null
@@ -1,132 +0,0 @@
-from keras.models import Sequential
-from keras.layers import Conv2D, Dense, Dropout, Flatten, MaxPooling2D
-from keras.datasets import mnist
-from keras.utils import to_categorical
-from sklearn.model_selection import train_test_split
-
-# from tensorflow.data.Dataset import from_tensor_slices
-import tensorflow as tf
-import os
-
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
-
-
-gpus = tf.config.experimental.list_physical_devices("GPU")
-if gpus:
- try:
- tf.config.experimental.set_memory_growth(gpus[0], True)
- except Exception as e:
- print(e)
- finally:
- del gpus
-
-
-def get_data():
- (x_train, y_train), (x_test, y_test) = mnist.load_data()
-
- x_train, x_test = x_train / 255.0, x_test / 255.0
- x_train = x_train.reshape((60000, 28, 28, 1))
- x_test = x_test.reshape((10000, 28, 28, 1))
-
- print(f"x_train : {x_train[0].shape} | y_train : {y_train[0].shape}")
- print(f"x_test : {x_test[0].shape} | y_test : {y_test[0].shape}")
-
- return x_train, y_train, x_test, y_test
-
-class _batch_generator_:
- def __init__(self, x, y, batch_size: int = None):
- self.index = 0
- self.x = x
- self.y = y
- self.setBatchSize(batch_size)
-
- def next(self):
- self.index += 1
- if self.index >= self.max_index:
- self.index = 0
- self.__getBatchSlice(self.batch_size)
- return self.dataset[self.index][0], self.dataset[self.index][1]
-
- def getMaxIndex(self):
- return self.max_index
-
- def getIndex(self):
- return self.index
-
- def setIndex(self, index):
- self.index = index
-
- def getBatchSize(self):
- return self.batch_size
-
- def setBatchSize(self, batch_size: int = None):
- if batch_size is None:
- batch_size = len(self.x) // 10
- elif batch_size > len(self.x):
- batch_size = len(self.x)
- self.batch_size = batch_size
- print(f"batch size : {self.batch_size}")
- self.dataset = self.__getBatchSlice(self.batch_size)
- self.max_index = len(self.dataset)
-
- def __getBatchSlice(self, batch_size):
- return list(
- tf.data.Dataset.from_tensor_slices((self.x, self.y))
- .shuffle(len(self.x))
- .batch(batch_size)
- )
-
- def getDataset(self):
- return self.dataset
-
-
-def make_model():
- model = Sequential()
- model.add(
- Conv2D(64, kernel_size=(5, 5), activation="relu", input_shape=(28, 28, 1))
- )
- model.add(MaxPooling2D(pool_size=(2, 2)))
- model.add(Dropout(0.5))
- model.add(Conv2D(128, kernel_size=(3, 3), activation="relu"))
- model.add(MaxPooling2D(pool_size=(2, 2)))
- model.add(Flatten())
- model.add(Dropout(0.5))
- model.add(Dense(2048, activation="relu"))
- model.add(Dropout(0.8))
- model.add(Dense(1024, activation="relu"))
- model.add(Dropout(0.8))
- model.add(Dense(10, activation="softmax"))
-
- return model
-
-
-model = make_model()
-x_train, y_train, x_test, y_test = get_data()
-y_train = tf.one_hot(y_train, 10)
-y_test = tf.one_hot(y_test, 10)
-
-batch = 64
-dataset = _batch_generator_(x_train, y_train, batch)
-
-model.compile(
- optimizer="adam",
- loss="categorical_crossentropy",
- metrics=["accuracy", "mse"],
-)
-
-count = 0
-print(f"batch size : {batch}")
-print("iter " + str(dataset.getMaxIndex()))
-print("Training model...")
-# while count < dataset.getMaxIndex():
-# x_batch, y_batch = dataset.next()
-# count += 1
-# print(f"iter {count}/{dataset.getMaxIndex()}")
-model.fit(x_train, y_train, epochs=1000, batch_size=batch, verbose=1)
-
-print(count)
-
-print("Evaluating model...")
-model.evaluate(x_test, y_test, verbose=1)
-
-weights = model.get_weights()
diff --git a/test/mnist_torch.py b/test/mnist_torch.py
new file mode 100644
index 0000000..e4d3392
--- /dev/null
+++ b/test/mnist_torch.py
@@ -0,0 +1,136 @@
+"""MNIST dataset gradient baseline (PyTorch standard backprop optimizer, non-PSO)."""
+
+import copy
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+
+class MNISTModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.conv1 = nn.Conv2d(1, 64, kernel_size=5)
+ self.relu1 = nn.ReLU()
+ self.pool1 = nn.MaxPool2d(2, 2)
+ self.drop1 = nn.Dropout(0.5)
+
+ self.conv2 = nn.Conv2d(64, 128, kernel_size=3)
+ self.relu2 = nn.ReLU()
+ self.pool2 = nn.MaxPool2d(2, 2)
+
+ self.drop2 = nn.Dropout(0.5)
+ self.fc1 = nn.Linear(128 * 5 * 5, 2048)
+ self.relu3 = nn.ReLU()
+ self.drop3 = nn.Dropout(0.8)
+
+ self.fc2 = nn.Linear(2048, 1024)
+ self.relu4 = nn.ReLU()
+ self.drop4 = nn.Dropout(0.8)
+
+ self.fc3 = nn.Linear(1024, 10)
+
+ def forward(self, x):
+ x = self.drop1(self.pool1(self.relu1(self.conv1(x))))
+ x = self.pool2(self.relu2(self.conv2(x)))
+ x = torch.flatten(x, 1)
+ x = self.drop3(self.relu3(self.fc1(self.drop2(x))))
+ x = self.drop4(self.relu4(self.fc2(x)))
+ x = self.fc3(x)
+ return x
+
+
+def get_data(download: bool = True):
+ from torchvision import datasets, transforms
+
+ transform = transforms.ToTensor()
+ train_dataset = datasets.MNIST(
+ root="./data", train=True, transform=transform, download=download
+ )
+ test_dataset = datasets.MNIST(
+ root="./data", train=False, transform=transform, download=download
+ )
+ return train_dataset, test_dataset
+
+
+def get_device() -> torch.device:
+ if (
+ hasattr(torch.backends, "mps")
+ and torch.backends.mps.is_built()
+ and torch.backends.mps.is_available()
+ ):
+ return torch.device("mps")
+ elif torch.cuda.is_available():
+ return torch.device("cuda")
+ return torch.device("cpu")
+
+
+def main():
+ torch.manual_seed(42)
+ np.random.seed(42)
+
+ device = get_device()
+ print(f"Selected device: {device}")
+
+ train_dataset, test_dataset = get_data(download=True)
+ train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
+ test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
+
+ model = MNISTModel().to(device)
+ optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+ criterion = nn.CrossEntropyLoss()
+
+ best_val_loss = float("inf")
+ best_state = None
+
+ for epoch in range(10):
+ model.train()
+ for bx, by in train_loader:
+ bx, by = bx.to(device), by.to(device)
+ optimizer.zero_grad()
+ out = model(bx)
+ loss = criterion(out, by)
+ loss.backward()
+ optimizer.step()
+
+ model.eval()
+ val_loss = 0.0
+ total = 0
+ with torch.no_grad():
+ for bx, by in test_loader:
+ bx, by = bx.to(device), by.to(device)
+ out = model(bx)
+ loss = criterion(out, by)
+ val_loss += loss.item() * bx.size(0)
+ total += bx.size(0)
+
+ val_loss /= total
+
+ if val_loss < best_val_loss:
+ best_val_loss = val_loss
+ best_state = copy.deepcopy(model.state_dict())
+
+ if best_state is not None:
+ model.load_state_dict(best_state)
+
+ model.eval()
+ test_loss = 0.0
+ correct = 0
+ total = 0
+ with torch.no_grad():
+ for bx, by in test_loader:
+ bx, by = bx.to(device), by.to(device)
+ out = model(bx)
+ loss = criterion(out, by)
+ test_loss += loss.item() * bx.size(0)
+ preds = out.argmax(dim=1)
+ correct += (preds == by).sum().item()
+ total += bx.size(0)
+
+ test_loss /= total
+ test_acc = correct / total
+ print(f"Final test loss: {test_loss:.4f}, accuracy: {test_acc:.4f}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/monitor_post_training_model_convergence.py b/test/monitor_post_training_model_convergence.py
new file mode 100644
index 0000000..185c40e
--- /dev/null
+++ b/test/monitor_post_training_model_convergence.py
@@ -0,0 +1,269 @@
+"""Emit live, read-only TensorBoard progress for a convergence-study run."""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from torch.utils.tensorboard import SummaryWriter
+
+BASE_SEEDS = (501, 502, 503)
+SWARM_SEEDS = (601, 602, 603)
+CIFAR_WORKLOADS = ("cifar10_resnet18", "cifar10_resnet50")
+YOLO_WORKLOAD = "voc_yolo11n"
+
+
+def _cifar_seed(root: Path, seed: int) -> dict[str, Any]:
+ baseline = root / f"baseline-{seed}.pt"
+ searches = sum(
+ (root / f"feature-{method}-{seed}-{swarm}.json").is_file()
+ for method in ("pso", "random")
+ for swarm in SWARM_SEEDS
+ )
+ controls = sum(
+ (root / f"{method}-{seed}.pt").is_file()
+ for method in ("feature-adam", "head-adam")
+ )
+ complete = baseline.is_file() and searches == 6 and controls == 2
+ if complete:
+ stage = "complete"
+ elif not baseline.is_file():
+ stage = "baseline_training"
+ elif searches < 6:
+ stage = f"pso_random_search_{searches}_of_6"
+ else:
+ stage = f"adam_controls_{controls}_of_2"
+ return {
+ "seed": seed,
+ "stage": stage,
+ "complete": complete,
+ "searches": searches,
+ "controls": controls,
+ }
+
+
+def _read_yolo_metrics(path: Path) -> list[dict[str, float]]:
+ if not path.is_file():
+ return []
+ try:
+ with path.open(newline="", encoding="utf-8") as stream:
+ rows = []
+ for source in csv.DictReader(stream):
+ rows.append(
+ {
+ key.strip(): float(value)
+ for key, value in source.items()
+ if key is not None
+ and value is not None
+ and value.strip()
+ }
+ )
+ return rows
+ except (OSError, ValueError):
+ return []
+
+
+def _yolo_seed(
+ root: Path,
+ run_root: Path,
+ seed: int,
+) -> dict[str, Any]:
+ baseline = root / "baselines" / str(seed) / "ema_fp32.pt"
+ training_root = (
+ run_root / "ultralytics" / f"base-{seed}-100e"
+ )
+ metrics = _read_yolo_metrics(training_root / "results.csv")
+ baseline_complete = (
+ baseline.is_file()
+ and len(metrics) >= 100
+ and (training_root / "weights" / "last.pt").is_file()
+ )
+ arm_root = root / "arms" / str(seed)
+ searches = sum(
+ (arm_root / f"feature_{method}-{swarm}.pt").is_file()
+ for method in ("pso", "random")
+ for swarm in SWARM_SEEDS
+ )
+ controls = sum(
+ (arm_root / f"{method}.pt").is_file()
+ for method in ("feature_adam", "head_adam")
+ )
+ complete = (arm_root / "record.json").is_file()
+ if complete:
+ stage = "complete"
+ elif not baseline_complete:
+ stage = f"baseline_training_epoch_{len(metrics)}_of_100"
+ elif searches < 6:
+ stage = f"pso_random_search_{searches}_of_6"
+ elif controls < 2:
+ stage = f"adam_controls_{controls}_of_2"
+ else:
+ stage = "selection"
+ return {
+ "seed": seed,
+ "stage": stage,
+ "complete": complete,
+ "searches": searches,
+ "controls": controls,
+ "training_metrics": metrics,
+ }
+
+
+def snapshot(run_root: Path) -> dict[str, Any]:
+ workloads = run_root / "workloads"
+ status: dict[str, Any] = {}
+ completed = 0
+ for workload in CIFAR_WORKLOADS:
+ seeds = [
+ _cifar_seed(workloads / workload, seed)
+ for seed in BASE_SEEDS
+ ]
+ completed += sum(item["complete"] for item in seeds)
+ status[workload] = seeds
+ yolo = [
+ _yolo_seed(
+ workloads / YOLO_WORKLOAD,
+ run_root,
+ seed,
+ )
+ for seed in BASE_SEEDS
+ ]
+ completed += sum(item["complete"] for item in yolo)
+ status[YOLO_WORKLOAD] = yolo
+ state_path = run_root / "state.json"
+ state = "missing"
+ if state_path.is_file():
+ try:
+ state = str(
+ json.loads(
+ state_path.read_text(encoding="utf-8")
+ ).get("state", "unknown")
+ )
+ except (OSError, ValueError):
+ state = "unreadable"
+ active = next(
+ (
+ f"{workload}/seed-{item['seed']}/{item['stage']}"
+ for workload, items in status.items()
+ for item in items
+ if not item["complete"]
+ ),
+ "",
+ )
+ if not active:
+ for workload in CIFAR_WORKLOADS:
+ selected = sum(
+ (
+ workloads
+ / workload
+ / f"selected-feature_{method}-{seed}.pt"
+ ).is_file()
+ for method in ("pso", "random")
+ for seed in BASE_SEEDS
+ )
+ if selected < 6:
+ active = (
+ f"{workload}/development_selection_"
+ f"{selected}_of_6"
+ )
+ break
+ if not active:
+ active = "development_complete"
+ return {
+ "state": state,
+ "active": active,
+ "completed_base_seeds": int(completed),
+ "total_base_seeds": 9,
+ "workloads": status,
+ "observed_at": time.time(),
+ }
+
+
+def emit(
+ writer: SummaryWriter,
+ value: dict[str, Any],
+ step: int,
+) -> None:
+ writer.add_scalar(
+ "progress/completed_base_seeds",
+ value["completed_base_seeds"],
+ step,
+ )
+ writer.add_scalar(
+ "progress/completion_fraction",
+ value["completed_base_seeds"] / value["total_base_seeds"],
+ step,
+ )
+ for workload, seeds in value["workloads"].items():
+ writer.add_scalar(
+ f"progress/{workload}/completed_base_seeds",
+ sum(item["complete"] for item in seeds),
+ step,
+ )
+ for item in value["workloads"][YOLO_WORKLOAD]:
+ seed = item["seed"]
+ for row in item["training_metrics"]:
+ epoch = int(row["epoch"])
+ for metric, metric_value in row.items():
+ if metric in {"epoch", "time"}:
+ continue
+ writer.add_scalar(
+ f"training/{YOLO_WORKLOAD}/seed_{seed}/{metric}",
+ metric_value,
+ epoch,
+ )
+ writer.add_text(
+ "progress/current",
+ f"`{value['active']}`",
+ step,
+ )
+ writer.add_text(
+ "progress/snapshot",
+ f"```json\n{json.dumps(value, indent=2)}\n```",
+ step,
+ )
+ writer.flush()
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--run-root", required=True, type=Path)
+ parser.add_argument("--interval", type=float, default=10.0)
+ parser.add_argument("--once", action="store_true")
+ args = parser.parse_args()
+ if args.interval <= 0:
+ raise SystemExit("--interval must be positive")
+ log_dir = args.run_root / "tensorboard"
+ writer = SummaryWriter(log_dir=str(log_dir))
+ print(f"monitoring {args.run_root} -> {log_dir}", flush=True)
+ step = 0
+ try:
+ while True:
+ value = snapshot(args.run_root)
+ emit(writer, value, step)
+ print(
+ json.dumps(
+ {
+ "active": value["active"],
+ "completed_base_seeds": value[
+ "completed_base_seeds"
+ ],
+ "state": value["state"],
+ },
+ sort_keys=True,
+ ),
+ flush=True,
+ )
+ step += 1
+ if args.once:
+ break
+ time.sleep(args.interval)
+ finally:
+ writer.close()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/post_training_model_convergence.py b/test/post_training_model_convergence.py
new file mode 100644
index 0000000..966b937
--- /dev/null
+++ b/test/post_training_model_convergence.py
@@ -0,0 +1,1947 @@
+"""Common protocol and search machinery for post-training convergence studies.
+
+This module deliberately contains no model or dataset implementation. Workload
+adapters register factories at runtime (the YOLO adapter is therefore imported
+only when its factory is invoked). The search code operates on a residual
+vector and a scalar objective so that classification and detection adapters can
+share exactly the same accounting and lifecycle rules.
+"""
+from __future__ import annotations
+
+import argparse
+import contextlib
+import copy
+import dataclasses
+import datetime as _datetime
+import hashlib
+import io
+import importlib
+import inspect
+import json
+import math
+import os
+from pathlib import Path
+import random
+import tempfile
+import sys
+from enum import Enum
+from types import MappingProxyType
+from typing import Any, Callable, Iterator, Mapping, Protocol, Sequence, runtime_checkable
+if __package__ in {None, ""}:
+ sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+
+import torch
+import torch.nn as nn
+
+from pso.optimizer import _RandomSource
+from pso.plugins import ConstrictionMovement, IterationContext, SwarmState
+
+
+PROTOCOL_VERSION = "post-training-model-convergence-1.0.0"
+DEFAULT_WORKLOAD_IDS = (
+ "cifar10_resnet18",
+ "cifar10_resnet50",
+ "voc_yolo11n",
+)
+BASE_SEEDS = (501, 502, 503)
+SWARM_SEEDS = (601, 602, 603)
+SPLIT_SEED = 20260908
+PROJECTION_SEED = 20260909
+BOOTSTRAP_SEED = 20260910
+PARTICLE_COUNT = 12
+PSO_GENERATIONS = 60
+RANDOM_CANDIDATES = PARTICLE_COUNT * PSO_GENERATIONS
+RESIDUAL_DIMENSION = 64
+RESIDUAL_BOUND = 1.0
+INITIAL_RADIUS = 0.25
+OBJECTIVE_CHECKPOINTS = (0, 10, 20, 30, 40, 50, 60)
+
+
+class ProtocolError(ValueError):
+ """Raised when an artifact or callback violates the study contract."""
+
+
+class ObjectiveEvaluationError(RuntimeError):
+ """Raised when a candidate objective cannot be evaluated."""
+
+
+class StateTransitionError(RuntimeError):
+ """Raised for an invalid or repeated study lifecycle transition."""
+
+
+class SealError(RuntimeError):
+ """Raised when a frozen artifact set cannot be confirmed."""
+
+
+@dataclasses.dataclass(frozen=True)
+class StudyConfig:
+ """Immutable protocol configuration shared by all workload adapters."""
+
+ protocol_version: str = PROTOCOL_VERSION
+ split_seed: int = SPLIT_SEED
+ base_seeds: tuple[int, ...] = BASE_SEEDS
+ swarm_seeds: tuple[int, ...] = SWARM_SEEDS
+ projection_seed: int = PROJECTION_SEED
+ bootstrap_seed: int = BOOTSTRAP_SEED
+ particle_count: int = PARTICLE_COUNT
+ pso_generations: int = PSO_GENERATIONS
+ residual_dimension: int = RESIDUAL_DIMENSION
+ residual_bound: float = RESIDUAL_BOUND
+ initial_radius: float = INITIAL_RADIUS
+ objective_checkpoints: tuple[int, ...] = OBJECTIVE_CHECKPOINTS
+ device: str = "cpu"
+ workload_ids: tuple[str, ...] = DEFAULT_WORKLOAD_IDS
+
+ def __post_init__(self) -> None:
+ if self.protocol_version != PROTOCOL_VERSION:
+ raise ProtocolError("protocol_version does not match the approved protocol")
+ if tuple(self.base_seeds) != BASE_SEEDS:
+ raise ProtocolError("base_seeds are fixed at 501, 502, 503")
+ if tuple(self.swarm_seeds) != SWARM_SEEDS:
+ raise ProtocolError("swarm_seeds are fixed at 601, 602, 603")
+ for name, value in (
+ ("split_seed", self.split_seed),
+ ("projection_seed", self.projection_seed),
+ ("bootstrap_seed", self.bootstrap_seed),
+ ("particle_count", self.particle_count),
+ ("pso_generations", self.pso_generations),
+ ("residual_dimension", self.residual_dimension),
+ ):
+ if isinstance(value, bool) or not isinstance(value, int):
+ raise ProtocolError(f"{name} must be an integer")
+ if self.split_seed != SPLIT_SEED:
+ raise ProtocolError(f"split_seed is fixed at {SPLIT_SEED}")
+ if self.projection_seed != PROJECTION_SEED:
+ raise ProtocolError(
+ f"projection_seed is fixed at {PROJECTION_SEED}"
+ )
+ if self.bootstrap_seed != BOOTSTRAP_SEED:
+ raise ProtocolError(
+ f"bootstrap_seed is fixed at {BOOTSTRAP_SEED}"
+ )
+ if self.particle_count != PARTICLE_COUNT or self.pso_generations != PSO_GENERATIONS:
+ raise ProtocolError("the primary PSO budget is fixed at 12x60")
+ if self.residual_dimension != RESIDUAL_DIMENSION:
+ raise ProtocolError("the residual dimension is fixed at 64")
+ if self.residual_bound != RESIDUAL_BOUND or self.initial_radius != INITIAL_RADIUS:
+ raise ProtocolError("residual bounds and initialization radius are fixed")
+ if tuple(self.objective_checkpoints) != OBJECTIVE_CHECKPOINTS:
+ raise ProtocolError("objective checkpoints are fixed")
+ if self.device not in {"cpu", "mps"}:
+ raise ProtocolError("device must be cpu or mps")
+ if not self.workload_ids:
+ raise ProtocolError("at least one workload must be registered")
+
+ def to_dict(self) -> dict[str, Any]:
+ return dataclasses.asdict(self)
+
+ @classmethod
+ def from_dict(cls, value: Mapping[str, Any]) -> "StudyConfig":
+ data = dict(value)
+ for key in ("base_seeds", "swarm_seeds", "objective_checkpoints", "workload_ids"):
+ if key in data:
+ data[key] = tuple(data[key])
+ return cls(**data)
+
+
+@dataclasses.dataclass(frozen=True)
+class ObjectiveResult:
+ """One finite scalar objective evaluation and its exact sample accounting."""
+
+ loss: float
+ samples: int
+ forward_passes: int = 0
+ backward_passes: int = 0
+ metadata: Mapping[str, Any] = dataclasses.field(default_factory=dict)
+
+ def __post_init__(self) -> None:
+ if isinstance(self.loss, bool) or not isinstance(self.loss, (int, float)):
+ raise ProtocolError("objective loss must be a scalar number")
+ if not math.isfinite(float(self.loss)):
+ raise FloatingPointError(f"non-finite objective loss: {self.loss!r}")
+ if isinstance(self.samples, bool) or not isinstance(self.samples, int) or self.samples < 0:
+ raise ProtocolError("objective samples must be a nonnegative integer")
+ for field in ("forward_passes", "backward_passes"):
+ count = getattr(self, field)
+ if isinstance(count, bool) or not isinstance(count, int) or count < 0:
+ raise ProtocolError(f"{field} must be a nonnegative integer")
+ object.__setattr__(self, "metadata", MappingProxyType(dict(self.metadata)))
+
+ @classmethod
+ def coerce(cls, value: "ObjectiveResult | float | int | torch.Tensor") -> "ObjectiveResult":
+ if isinstance(value, cls):
+ return value
+ if torch.is_tensor(value):
+ if value.ndim != 0:
+ raise ProtocolError("objective tensor result must be scalar")
+ value = value.detach().item()
+ if isinstance(value, bool) or not isinstance(value, (float, int)):
+ raise ProtocolError("objective callback must return ObjectiveResult or scalar float")
+ return cls(loss=float(value), samples=0)
+
+ def to_dict(self) -> dict[str, Any]:
+ return {
+ "loss": float(self.loss),
+ "samples": self.samples,
+ "forward_passes": self.forward_passes,
+ "backward_passes": self.backward_passes,
+ "metadata": _jsonable(self.metadata),
+ }
+
+
+@dataclasses.dataclass(frozen=True)
+class AuditResult:
+ """Read-only validation/audit result; it is never used by the optimizer."""
+
+ loss: float
+ primary_metric: float | None = None
+ samples: int = 0
+ metadata: Mapping[str, Any] = dataclasses.field(default_factory=dict)
+
+ def __post_init__(self) -> None:
+ if not math.isfinite(float(self.loss)):
+ raise FloatingPointError("audit loss must be finite")
+ if self.primary_metric is not None and not math.isfinite(float(self.primary_metric)):
+ raise FloatingPointError("audit metric must be finite")
+ if isinstance(self.samples, bool) or not isinstance(self.samples, int) or self.samples < 0:
+ raise ProtocolError("audit samples must be a nonnegative integer")
+ object.__setattr__(self, "metadata", MappingProxyType(dict(self.metadata)))
+
+ def to_dict(self) -> dict[str, Any]:
+ return {
+ "loss": float(self.loss),
+ "primary_metric": self.primary_metric,
+ "samples": self.samples,
+ "metadata": _jsonable(self.metadata),
+ }
+
+
+@runtime_checkable
+class ObjectiveCallback(Protocol):
+ def __call__(self, residual: torch.Tensor) -> ObjectiveResult | float: ...
+
+
+@runtime_checkable
+class AuditCallback(Protocol):
+ def __call__(self, residual: torch.Tensor) -> AuditResult | Mapping[str, Any] | float: ...
+
+
+@dataclasses.dataclass
+class ResourceCounters:
+ """Counters for every expensive operation, including failed candidates."""
+
+ objective_queries: int = 0
+ objective_samples: int = 0
+ objective_failures: int = 0
+ objective_forward_passes: int = 0
+ objective_backward_passes: int = 0
+ validation_evaluations: int = 0
+ validation_samples: int = 0
+ gradient_updates: int = 0
+ gradient_samples: int = 0
+ full_forward_passes: int = 0
+ test_forward_passes: int = 0
+ cache_forward_passes: int = 0
+ fusion_evaluations: int = 0
+ solver_evaluations: int = 0
+ bytes_written: int = 0
+ wall_time_seconds: float = 0.0
+
+ def record_objective(self, result: ObjectiveResult | None, *, failed: bool, fallback_samples: int = 0) -> None:
+ self.objective_queries += 1
+ if failed:
+ self.objective_failures += 1
+ if result is None:
+ self.objective_samples += fallback_samples
+ return
+ self.objective_samples += result.samples
+ self.objective_forward_passes += result.forward_passes
+ self.objective_backward_passes += result.backward_passes
+
+ def merge(self, other: "ResourceCounters") -> None:
+ for field in dataclasses.fields(self):
+ setattr(self, field.name, getattr(self, field.name) + getattr(other, field.name))
+
+ def to_dict(self) -> dict[str, Any]:
+ return dataclasses.asdict(self)
+
+
+@dataclasses.dataclass(frozen=True)
+class CandidateEndpoint:
+ generation: int
+ particle_index: int
+ residual: torch.Tensor
+ objective: ObjectiveResult
+
+ def __post_init__(self) -> None:
+ if not torch.is_tensor(self.residual):
+ raise ProtocolError("endpoint residual must be a tensor")
+ if self.residual.ndim != 1:
+ raise ProtocolError("endpoint residual must be one-dimensional")
+ object.__setattr__(self, "residual", self.residual.detach().clone())
+
+ def to_dict(self, *, include_vector: bool = False) -> dict[str, Any]:
+ value = {
+ "generation": self.generation,
+ "particle_index": self.particle_index,
+ "objective": self.objective.to_dict(),
+ }
+ if include_vector:
+ value["residual"] = self.residual.detach().cpu().tolist()
+ return value
+
+
+@dataclasses.dataclass
+class SearchResult:
+ method: str
+ seed: int
+ generations: int
+ particles: int
+ best_residual: torch.Tensor | None
+ best_objective: ObjectiveResult | None
+ endpoints: tuple[CandidateEndpoint, ...]
+ trajectory: tuple[dict[str, Any], ...]
+ counters: ResourceCounters
+ failures: tuple[str, ...] = ()
+
+ @property
+ def objective_queries(self) -> int:
+ return self.counters.objective_queries
+
+ def to_dict(self, *, include_vectors: bool = False) -> dict[str, Any]:
+ return {
+ "method": self.method,
+ "seed": self.seed,
+ "generations": self.generations,
+ "particles": self.particles,
+ "best_objective": None if self.best_objective is None else self.best_objective.to_dict(),
+ "best_residual": None
+ if self.best_residual is None or not include_vectors
+ else self.best_residual.detach().cpu().tolist(),
+ "endpoints": [e.to_dict(include_vector=include_vectors) for e in self.endpoints],
+ "trajectory": [_jsonable(row) for row in self.trajectory],
+ "counters": self.counters.to_dict(),
+ "failures": list(self.failures),
+ }
+
+
+# Integer arithmetic, rather than Python's process-randomized hash(), defines
+# the projection and makes it reproducible across machines and processes.
+def projection_salt(names: Sequence[str], seed: int = PROJECTION_SEED) -> int:
+ payload = (str(seed) + "\0" + "\0".join(names)).encode("utf-8")
+ return int.from_bytes(hashlib.sha256(payload).digest()[:8], "little") & 0xFFFFFFFF
+
+
+def _projection_arrays(total: int, dimension: int, salt: int) -> tuple[torch.Tensor, torch.Tensor]:
+ indices = []
+ signs = []
+ for j in range(total):
+ first = ((j + 1) * 0x9E3779B1 + salt * 0x85EBCA77) & 0xFFFFFFFF
+ second = ((j + 1) * 0xC2B2AE3D + salt * 0x27D4EB2F) & 0xFFFFFFFF
+ indices.append(first % dimension)
+ signs.append(1.0 if (second & 1) == 0 else -1.0)
+ return torch.tensor(indices, dtype=torch.long), torch.tensor(signs, dtype=torch.float32)
+
+
+class SelectedResidualCodec:
+ """Exact-name, immutable residual codec for one selected parameter layout.
+
+ The projection is sparse by construction: each selected scalar reads one
+ latent coordinate and one deterministic sign. No dense ``D x 64`` matrix
+ is allocated. ``apply`` always starts and ends at the codec's fp32 base
+ state, including when the callback raises.
+ """
+
+ dimension = RESIDUAL_DIMENSION
+
+ def __init__(
+ self,
+ model: nn.Module,
+ names: Sequence[str] | None = None,
+ *,
+ selected_names: Sequence[str] | None = None,
+ projection_seed: int = PROJECTION_SEED,
+ ) -> None:
+ if names is None:
+ names = selected_names
+ elif selected_names is not None and tuple(names) != tuple(selected_names):
+ raise ProtocolError("names and selected_names disagree")
+ if names is None:
+ raise ProtocolError("selected parameter names are required")
+ if tuple(names) != tuple(dict.fromkeys(names)) or not names:
+ raise ProtocolError("selected parameter names must be nonempty and unique")
+ named = dict(model.named_parameters())
+ unknown = [name for name in names if name not in named]
+ if unknown:
+ raise ProtocolError(f"selected parameter names are absent: {unknown}")
+ tensors: list[torch.Tensor] = []
+ shapes: list[tuple[int, ...]] = []
+ offsets: list[int] = []
+ scales: list[float] = []
+ cursor = 0
+ for name in names:
+ parameter = named[name]
+ if not parameter.is_floating_point():
+ raise ProtocolError(f"selected parameter is not floating point: {name}")
+ value = parameter.detach().to(device="cpu", dtype=torch.float32).clone()
+ tensors.append(value)
+ shape = tuple(value.shape)
+ shapes.append(shape)
+ offsets.append(cursor)
+ cursor += value.numel()
+ rms = float(torch.sqrt(torch.mean(value * value))) if value.numel() else 0.0
+ scales.append(0.05 * max(rms, 0.01))
+ indices, signs = _projection_arrays(cursor, self.dimension, projection_salt(names, projection_seed))
+ self._names = tuple(names)
+ self._shapes = tuple(shapes)
+ self._offsets = tuple(offsets)
+ self._base_values = tuple(tensors)
+ self._scales = tuple(scales)
+ self._projection_indices = indices
+ self._projection_signs = signs
+ self._total_numel = cursor
+ self._projection_seed = int(projection_seed)
+ self._name_to_position = MappingProxyType({name: i for i, name in enumerate(self._names)})
+ self._nonselected_base = MappingProxyType(
+ {
+ name: parameter.detach().to(device="cpu").clone()
+ for name, parameter in named.items()
+ if name not in self._name_to_position
+ }
+ )
+
+ @property
+ def names(self) -> tuple[str, ...]:
+ return self._names
+
+ @property
+ def shapes(self) -> tuple[tuple[int, ...], ...]:
+ return self._shapes
+
+ @property
+ def offsets(self) -> tuple[int, ...]:
+ return self._offsets
+
+ @property
+ def total_numel(self) -> int:
+ return self._total_numel
+
+ @property
+ def projection_seed(self) -> int:
+ return self._projection_seed
+
+ @property
+ def scales(self) -> tuple[float, ...]:
+ return self._scales
+
+ @property
+ def base_values(self) -> tuple[torch.Tensor, ...]:
+ return tuple(value.clone() for value in self._base_values)
+
+ @property
+ def projection_indices(self) -> torch.Tensor:
+ return self._projection_indices.clone()
+
+ def _validate_residual(self, residual: torch.Tensor) -> torch.Tensor:
+ if not torch.is_tensor(residual):
+ raise ProtocolError("residual must be a tensor")
+ if residual.ndim != 1 or residual.numel() != self.dimension:
+ raise ProtocolError(f"residual must have shape ({self.dimension},)")
+ if not residual.is_floating_point():
+ residual = residual.float()
+ if not bool(torch.isfinite(residual).all().item()):
+ raise FloatingPointError("residual contains non-finite values")
+ if bool(((residual < -RESIDUAL_BOUND) | (residual > RESIDUAL_BOUND)).any().item()):
+ raise ProtocolError(f"residual must lie in [{-RESIDUAL_BOUND}, {RESIDUAL_BOUND}]")
+ return residual
+
+ def residual_values(self, residual: torch.Tensor) -> tuple[torch.Tensor, ...]:
+ z = self._validate_residual(residual)
+ device, dtype = z.device, z.dtype
+ if not bool(torch.count_nonzero(z).item()):
+ return tuple(base.to(device=device, dtype=dtype).clone() for base in self._base_values)
+ indices = self._projection_indices.to(device=device)
+ signs = self._projection_signs.to(device=device, dtype=dtype)
+ values: list[torch.Tensor] = []
+ for index, (base, offset) in enumerate(zip(self._base_values, self._offsets)):
+ end = offset + base.numel()
+ chosen = z.index_select(0, indices[offset:end]) * signs[offset:end]
+ values.append(base.to(device=device, dtype=dtype).view(-1).add(chosen * self._scales[index]).view(base.shape))
+ return tuple(values)
+
+ def residual_delta(self, residual: torch.Tensor) -> torch.Tensor:
+ z = self._validate_residual(residual)
+ indices = self._projection_indices.to(device=z.device)
+ signs = self._projection_signs.to(device=z.device, dtype=z.dtype)
+ scale_parts = [
+ torch.full((base.numel(),), self._scales[i], device=z.device, dtype=z.dtype)
+ for i, base in enumerate(self._base_values)
+ ]
+ scales = torch.cat(scale_parts) if scale_parts else torch.empty(0, device=z.device, dtype=z.dtype)
+ return z.index_select(0, indices) * signs * scales
+
+ def decode(self, residual: torch.Tensor) -> torch.Tensor:
+ """Return the selected parameters' candidate fp32/latent-device vector."""
+ return torch.cat([value.reshape(-1) for value in self.residual_values(residual)])
+
+ def decode_delta(self, residual: torch.Tensor) -> torch.Tensor:
+ return self.residual_delta(residual)
+
+ def zero_residual(self, *, device: torch.device | str = "cpu", dtype: torch.dtype = torch.float32) -> torch.Tensor:
+ return torch.zeros(self.dimension, device=device, dtype=dtype)
+
+ def _check_model(self, model: nn.Module) -> dict[str, nn.Parameter]:
+ named = dict(model.named_parameters())
+ missing = [name for name in self._names if name not in named]
+ if missing:
+ raise ProtocolError(f"model is missing selected names: {missing}")
+ return named
+
+ def restore_base(self, model: nn.Module) -> None:
+ named = self._check_model(model)
+ with torch.no_grad():
+ for name, base in zip(self._names, self._base_values):
+ target = named[name]
+ target.copy_(base.to(device=target.device, dtype=target.dtype).view_as(target))
+
+ def apply_residual(self, model: nn.Module, residual: torch.Tensor) -> None:
+ named = self._check_model(model)
+ values = self.residual_values(residual)
+ with torch.no_grad():
+ for name, value in zip(self._names, values):
+ target = named[name]
+ target.copy_(value.to(device=target.device, dtype=target.dtype).view_as(target))
+
+ def apply(self, model: nn.Module, residual: torch.Tensor) -> None:
+ """Apply a candidate in-place; call ``restore_base`` after evaluation."""
+ self.apply_residual(model, residual)
+
+ @contextlib.contextmanager
+ def applied(self, model: nn.Module, residual: torch.Tensor) -> Iterator[nn.Module]:
+ """Apply one candidate without copying the frozen model per query.
+
+ Selected parameters and buffers are restored with ``copy_`` and module
+ modes are preserved. Non-selected parameter version counters provide a
+ cheap mutation guard; adapters additionally verify full state hashes at
+ run boundaries, as required by the protocol.
+ """
+ z = self._validate_residual(residual)
+ parameters = dict(model.named_parameters())
+ buffers = dict(model.named_buffers())
+ missing = [name for name in self._names if name not in parameters]
+ if missing:
+ raise ProtocolError(f"model is missing selected names: {missing}")
+ selected = set(self._names)
+ nonselected_versions = {
+ name: parameter._version
+ for name, parameter in parameters.items()
+ if name not in selected
+ }
+ buffer_snapshot = {
+ name: value.detach().clone()
+ for name, value in buffers.items()
+ }
+ modes = {name: child.training for name, child in model.named_modules()}
+ try:
+ self.restore_base(model)
+ model.eval()
+ self.apply_residual(model, z)
+ if not bool(torch.count_nonzero(z).item()):
+ for name, base in zip(self._names, self._base_values):
+ expected = base.to(
+ device=parameters[name].device,
+ dtype=parameters[name].dtype,
+ )
+ if not torch.equal(parameters[name].detach(), expected):
+ raise ProtocolError(
+ "zero residual did not preserve exact baseline parameters"
+ )
+ yield model
+ changed = [
+ name
+ for name, parameter in parameters.items()
+ if name not in selected
+ and parameter._version != nonselected_versions[name]
+ ]
+ if changed:
+ raise ProtocolError(
+ f"candidate mutated non-selected parameters: {changed[:3]}"
+ )
+ finally:
+ changed_now = [
+ name
+ for name, parameter in parameters.items()
+ if name not in selected
+ and parameter._version != nonselected_versions[name]
+ ]
+ with torch.no_grad():
+ for name in changed_now:
+ parameters[name].copy_(
+ self._nonselected_base[name].to(
+ device=parameters[name].device,
+ dtype=parameters[name].dtype,
+ )
+ )
+ with torch.no_grad():
+ for name, saved in buffer_snapshot.items():
+ buffers[name].copy_(
+ saved.to(device=buffers[name].device, dtype=buffers[name].dtype)
+ )
+ for name, child in model.named_modules():
+ child.train(bool(modes[name]))
+ self.restore_base(model)
+
+ def evaluate(self, model: nn.Module, residual: torch.Tensor, callback: Callable[[], Any]) -> Any:
+ with self.applied(model, residual):
+ return callback()
+
+ def selected_state_fingerprint(self, model: nn.Module) -> str:
+ named = self._check_model(model)
+ return _fingerprint_tensors((name, named[name]) for name in self._names)
+
+
+@dataclasses.dataclass(frozen=True)
+class _Evaluation:
+ residual: torch.Tensor
+ objective: ObjectiveResult | None
+ error: str | None
+
+
+def _evaluate_candidate(
+ objective: ObjectiveCallback,
+ residual: torch.Tensor,
+ counters: ResourceCounters,
+ failures: list[str],
+ *,
+ codec: SelectedResidualCodec | None,
+ model: nn.Module | None,
+ fallback_samples: int,
+) -> _Evaluation:
+ candidate = residual.detach().clone()
+ try:
+ if codec is not None and model is not None:
+ with codec.applied(model, candidate):
+ value = objective(candidate.clone())
+ else:
+ value = objective(candidate.clone())
+ result = ObjectiveResult.coerce(value)
+ counters.record_objective(result, failed=False)
+ return _Evaluation(candidate, result, None)
+ except Exception as exc:
+ counters.record_objective(None, failed=True, fallback_samples=fallback_samples)
+ message = f"{type(exc).__name__}: {exc}"
+ failures.append(message)
+ return _Evaluation(candidate, None, message)
+
+
+def _initial_positions(rng: _RandomSource, particles: int, dimension: int, device: torch.device) -> list[torch.Tensor]:
+ if particles != PARTICLE_COUNT:
+ raise ProtocolError("the convergence protocol requires exactly 12 particles")
+ positions = [torch.zeros(dimension, device=device, dtype=torch.float32)]
+ for _ in range(5):
+ sample = rng.uniform((dimension,), -INITIAL_RADIUS, INITIAL_RADIUS, device=device, dtype=torch.float32)
+ positions.extend((sample, -sample))
+ positions.append(rng.uniform((dimension,), -INITIAL_RADIUS, INITIAL_RADIUS, device=device, dtype=torch.float32))
+ return [position.detach().clone() for position in positions]
+
+
+def _is_strictly_better(loss: float, incumbent: float | None) -> bool:
+ if not math.isfinite(loss):
+ raise FloatingPointError("objective comparator received a non-finite loss")
+ return incumbent is None or loss < incumbent
+
+
+def _validation_snapshot(model: nn.Module | None) -> dict[str, Any]:
+ snapshot: dict[str, Any] = {
+ "python": random.getstate(),
+ "torch_cpu": torch.get_rng_state().clone(),
+ }
+ if hasattr(torch, "cuda") and torch.cuda.is_available():
+ snapshot["torch_cuda"] = [state.clone() for state in torch.cuda.get_rng_state_all()]
+ if model is not None:
+ snapshot["state"] = {name: value.detach().cpu().clone() for name, value in model.state_dict().items()}
+ snapshot["training"] = {module: child.training for module, child in model.named_modules()}
+ try:
+ import numpy as np
+ snapshot["numpy"] = copy.deepcopy(np.random.get_state())
+ except ImportError:
+ pass
+ return snapshot
+
+
+def _restore_validation_snapshot(model: nn.Module | None, snapshot: Mapping[str, Any]) -> None:
+ random.setstate(snapshot["python"])
+ torch.set_rng_state(snapshot["torch_cpu"])
+ if "torch_cuda" in snapshot:
+ torch.cuda.set_rng_state_all(snapshot["torch_cuda"])
+ if "numpy" in snapshot:
+ import numpy as np
+ np.random.set_state(snapshot["numpy"])
+ if model is not None:
+ model.load_state_dict(snapshot["state"], strict=True)
+ for name, child in model.named_modules():
+ child.train(bool(snapshot["training"][name]))
+
+
+@contextlib.contextmanager
+def state_neutral_audit(model: nn.Module | None = None) -> Iterator[None]:
+ """Preserve model parameters, buffers, modes, and host/device RNG state."""
+ snapshot = _validation_snapshot(model)
+ try:
+ if model is not None:
+ model.eval()
+ with torch.no_grad():
+ yield
+ finally:
+ _restore_validation_snapshot(model, snapshot)
+
+
+def run_state_neutral_audit(
+ model: nn.Module,
+ callback: Callable[[], AuditResult | Mapping[str, Any] | float],
+) -> AuditResult | Mapping[str, Any] | float:
+ with state_neutral_audit(model):
+ return callback()
+
+
+def _call_validation(
+ callback: AuditCallback | None,
+ residual: torch.Tensor,
+ counters: ResourceCounters,
+ *,
+ model: nn.Module | None,
+) -> AuditResult | Mapping[str, Any] | float | None:
+ if callback is None:
+ return None
+ snapshot = _validation_snapshot(model)
+ try:
+ if model is not None:
+ model.eval()
+ with torch.no_grad():
+ result = callback(residual.detach().clone())
+ if isinstance(result, AuditResult):
+ counters.validation_evaluations += 1
+ counters.validation_samples += result.samples
+ elif isinstance(result, Mapping):
+ counters.validation_evaluations += 1
+ else:
+ counters.validation_evaluations += 1
+ return result
+ finally:
+ _restore_validation_snapshot(model, snapshot)
+
+
+def _run_search(
+ objective: ObjectiveCallback,
+ *,
+ seed: int,
+ method: str,
+ generations: int,
+ particles: int,
+ device: torch.device | str,
+ codec: SelectedResidualCodec | None,
+ model: nn.Module | None,
+ validation: AuditCallback | None,
+ fallback_samples: int,
+ random_mode: bool,
+) -> SearchResult:
+ if generations != PSO_GENERATIONS or particles != PARTICLE_COUNT:
+ raise ProtocolError("primary search budget must be exactly 12 particles x 60 generations")
+ if isinstance(seed, bool) or not isinstance(seed, int):
+ raise ProtocolError("seed must be an integer")
+ resolved = torch.device(device)
+ rng = _RandomSource(seed=seed, device=resolved)
+ positions = _initial_positions(rng, particles, RESIDUAL_DIMENSION, resolved)
+ velocities = [torch.zeros_like(position) for position in positions]
+ pbest_positions = [position.clone() for position in positions]
+ pbest_losses: list[float | None] = [None] * particles
+ gbest_position: torch.Tensor | None = None
+ gbest_loss: float | None = None
+ gbest_result: ObjectiveResult | None = None
+ gbest_index = 0
+ counters = ResourceCounters()
+ failures: list[str] = []
+ endpoints: list[CandidateEndpoint] = []
+ trajectory: list[dict[str, Any]] = []
+ movement = ConstrictionMovement(c0=2.05, c1=2.05)
+ initial_validation = _call_validation(
+ validation,
+ positions[0],
+ counters,
+ model=model,
+ )
+
+ def evaluate_generation(gen: int, generation_positions: Sequence[torch.Tensor]) -> None:
+ nonlocal gbest_position, gbest_loss, gbest_result, gbest_index
+ generation_values: list[_Evaluation] = []
+ for index, candidate in enumerate(generation_positions):
+ evaluation = _evaluate_candidate(
+ objective,
+ candidate,
+ counters,
+ failures,
+ codec=codec,
+ model=model,
+ fallback_samples=fallback_samples,
+ )
+ generation_values.append(evaluation)
+ if evaluation.objective is None:
+ continue
+ loss = evaluation.objective.loss
+ if _is_strictly_better(loss, pbest_losses[index]):
+ pbest_losses[index] = loss
+ pbest_positions[index] = candidate.detach().clone()
+ if _is_strictly_better(loss, gbest_loss):
+ gbest_loss = loss
+ gbest_position = candidate.detach().clone()
+ gbest_result = evaluation.objective
+ gbest_index = index
+ if gbest_position is None or gbest_loss is None or gbest_result is None:
+ raise ObjectiveEvaluationError("all objective candidates failed")
+ best_result = gbest_result
+ if gen in OBJECTIVE_CHECKPOINTS:
+ validation_result = _call_validation(validation, gbest_position, counters, model=model)
+ else:
+ validation_result = None
+ velocity_norm = float(torch.stack([v.norm() for v in velocities]).mean().item())
+ trajectory.append({
+ "generation": gen,
+ "objective_best": float(gbest_loss),
+ "velocity_norm": velocity_norm,
+ "displacement_norm": float(torch.stack([p.norm() for p in generation_positions]).mean().item()),
+ "best_vector_norm": float(gbest_position.norm().item()),
+ "validation": None if validation_result is None else _jsonable(validation_result.to_dict() if isinstance(validation_result, AuditResult) else validation_result),
+ })
+ if gen == 1:
+ trajectory[-1]["initial_validation"] = (
+ None
+ if initial_validation is None
+ else _jsonable(
+ initial_validation.to_dict()
+ if isinstance(initial_validation, AuditResult)
+ else initial_validation
+ )
+ )
+ endpoints.append(CandidateEndpoint(gen, gbest_index, gbest_position, best_result))
+
+ evaluate_generation(1, positions)
+ for generation in range(2, generations + 1):
+ state = SwarmState(
+ positions=tuple(position.clone() for position in positions),
+ velocities=tuple(velocity.clone() for velocity in velocities),
+ pbest_positions=tuple(position.clone() for position in pbest_positions),
+ pbest_scores=tuple((loss if loss is not None else math.inf, 0.0, 0.0) for loss in pbest_losses),
+ gbest_position=gbest_position.clone(),
+ gbest_score=(gbest_loss, 0.0, 0.0),
+ pbest_improved=tuple(False for _ in positions),
+ )
+ proposed: list[torch.Tensor] = []
+ proposed_velocities: list[torch.Tensor] = []
+ for index in range(particles):
+ if random_mode:
+ velocity = velocities[index]
+ candidate = rng.uniform((RESIDUAL_DIMENSION,), -RESIDUAL_BOUND, RESIDUAL_BOUND, device=resolved, dtype=torch.float32)
+ else:
+ context = IterationContext(
+ epoch=generation,
+ total_epochs=generations,
+ w=1.0,
+ particle_idx=index,
+ is_negative=False,
+ rng=rng,
+ optimizer=None,
+ )
+ _, velocity = movement.propose(index, state, context)
+ candidate = positions[index] + velocity
+ outside = (candidate < -RESIDUAL_BOUND) | (candidate > RESIDUAL_BOUND)
+ candidate = torch.clamp(candidate, -RESIDUAL_BOUND, RESIDUAL_BOUND)
+ velocity = torch.where(outside, torch.zeros_like(velocity), velocity)
+ proposed.append(candidate.detach().clone())
+ proposed_velocities.append(velocity.detach().clone())
+ velocities = proposed_velocities
+ positions = proposed
+ evaluate_generation(generation, positions)
+
+ assert gbest_position is not None and gbest_loss is not None
+ best_endpoint = endpoints[-1]
+ return SearchResult(
+ method=method,
+ seed=seed,
+ generations=generations,
+ particles=particles,
+ best_residual=gbest_position.detach().clone(),
+ best_objective=ObjectiveResult(gbest_loss, best_endpoint.objective.samples, best_endpoint.objective.forward_passes, best_endpoint.objective.backward_passes),
+ endpoints=tuple(endpoints),
+ trajectory=tuple(trajectory),
+ counters=counters,
+ failures=tuple(failures),
+ )
+
+
+def run_residual_pso(
+ objective: ObjectiveCallback,
+ codec: SelectedResidualCodec | None = None,
+ *,
+ seed: int,
+ generations: int = PSO_GENERATIONS,
+ particles: int = PARTICLE_COUNT,
+ device: torch.device | str = "cpu",
+ model: nn.Module | None = None,
+ validation: AuditCallback | None = None,
+ objective_samples: int = 0,
+) -> SearchResult:
+ """Run the fixed 12x60 constriction PSO with exactly 720 evaluations."""
+ return _run_search(
+ objective,
+ seed=seed,
+ method="feature_pso",
+ generations=generations,
+ particles=particles,
+ device=device,
+ codec=codec,
+ model=model,
+ validation=validation,
+ fallback_samples=objective_samples,
+ random_mode=False,
+ )
+
+
+def run_equal_budget_random(
+ objective: ObjectiveCallback,
+ codec: SelectedResidualCodec | None = None,
+ *,
+ seed: int,
+ generations: int = PSO_GENERATIONS,
+ particles: int = PARTICLE_COUNT,
+ device: torch.device | str = "cpu",
+ model: nn.Module | None = None,
+ validation: AuditCallback | None = None,
+ objective_samples: int = 0,
+) -> SearchResult:
+ """Run the equal-query random control: 12 initial + 708 U[-1,1]."""
+ return _run_search(
+ objective,
+ seed=seed,
+ method="feature_random",
+ generations=generations,
+ particles=particles,
+ device=device,
+ codec=codec,
+ model=model,
+ validation=validation,
+ fallback_samples=objective_samples,
+ random_mode=True,
+ )
+
+
+run_random_search = run_equal_budget_random
+
+
+class StudyState(str, Enum):
+ PREPARED = "prepared"
+ DEVELOPING = "developing"
+ FROZEN = "frozen"
+ CONFIRMING = "confirming"
+ COMPLETED = "completed"
+ FAILED = "failed"
+
+
+RunState = StudyState
+_ALLOWED_TRANSITIONS = {
+ StudyState.PREPARED: {StudyState.DEVELOPING, StudyState.FAILED},
+ StudyState.DEVELOPING: {StudyState.FROZEN, StudyState.FAILED},
+ StudyState.FROZEN: {StudyState.CONFIRMING, StudyState.FAILED},
+ StudyState.CONFIRMING: {StudyState.COMPLETED, StudyState.FAILED},
+ StudyState.COMPLETED: set(),
+ StudyState.FAILED: set(),
+}
+
+
+@dataclasses.dataclass
+class StudyStateMachine:
+ state: StudyState = StudyState.PREPARED
+ history: list[dict[str, Any]] = dataclasses.field(default_factory=list)
+ failure_reason: str | None = None
+
+ def transition(self, target: StudyState | str, *, detail: str | None = None) -> StudyState:
+ target_state = StudyState(target)
+ if target_state not in _ALLOWED_TRANSITIONS[self.state]:
+ raise StateTransitionError(f"invalid transition {self.state.value} -> {target_state.value}")
+ previous = self.state
+ self.state = target_state
+ if target_state == StudyState.FAILED:
+ self.failure_reason = detail or "unspecified protocol failure"
+ self.history.append({"from": previous.value, "to": target_state.value, "detail": detail})
+ return self.state
+
+ def fail(self, reason: str) -> StudyState:
+ if not reason:
+ raise ProtocolError("failure reason must not be empty")
+ return self.transition(StudyState.FAILED, detail=reason)
+
+ def require(self, expected: StudyState | str) -> None:
+ target = StudyState(expected)
+ if self.state != target:
+ raise StateTransitionError(f"expected state {target.value}, found {self.state.value}")
+
+ def to_dict(self) -> dict[str, Any]:
+ return {"state": self.state.value, "history": list(self.history), "failure_reason": self.failure_reason}
+
+
+@dataclasses.dataclass(frozen=True)
+class WorkloadSpec:
+ workload_id: str
+ family: str
+ adapter_factory: Callable[..., Any]
+ metadata: Mapping[str, Any] = dataclasses.field(default_factory=dict)
+
+ def __post_init__(self) -> None:
+ if not self.workload_id or not self.family or not callable(self.adapter_factory):
+ raise ProtocolError("workload spec requires id, family, and callable factory")
+ object.__setattr__(self, "metadata", MappingProxyType(dict(self.metadata)))
+
+
+_WORKLOADS: dict[str, WorkloadSpec] = {}
+
+
+def register_workload(spec: WorkloadSpec, *, replace: bool = False) -> WorkloadSpec:
+ if spec.workload_id in _WORKLOADS and not replace:
+ raise ProtocolError(f"workload already registered: {spec.workload_id}")
+ _WORKLOADS[spec.workload_id] = spec
+ return spec
+
+
+def get_workload(workload_id: str) -> WorkloadSpec:
+ try:
+ return _WORKLOADS[workload_id]
+ except KeyError as exc:
+ raise ProtocolError(f"unknown workload: {workload_id}") from exc
+
+
+def registered_workloads() -> tuple[WorkloadSpec, ...]:
+ return tuple(_WORKLOADS[workload_id] for workload_id in sorted(_WORKLOADS))
+
+
+def _lazy_adapter(module_name: str) -> Callable[..., Any]:
+ def factory(*args: Any, **kwargs: Any) -> Any:
+ module = importlib.import_module(module_name)
+ creator = getattr(module, "create_adapter", None)
+ if creator is None or not callable(creator):
+ raise ProtocolError(f"adapter module {module_name!r} does not expose create_adapter")
+ return creator(*args, **kwargs)
+ return factory
+
+
+register_workload(WorkloadSpec("cifar10_resnet18", "classification", _lazy_adapter("test.post_training_resnet_convergence"), {"model": "resnet18", "dataset": "cifar10"}))
+register_workload(WorkloadSpec("cifar10_resnet50", "classification", _lazy_adapter("test.post_training_resnet_convergence"), {"model": "resnet50", "dataset": "cifar10"}))
+register_workload(WorkloadSpec("voc_yolo11n", "detection", _lazy_adapter("test.post_training_yolo_convergence"), {"model": "yolo11n", "dataset": "voc2007+2012", "optional_dependency": "ultralytics==8.4.142"}))
+
+
+def _jsonable(value: Any) -> Any:
+ if isinstance(value, Mapping):
+ return {str(key): _jsonable(item) for key, item in value.items()}
+ if isinstance(value, (tuple, list)):
+ return [_jsonable(item) for item in value]
+ if isinstance(value, Enum):
+ return value.value
+ if torch.is_tensor(value):
+ return value.detach().cpu().tolist()
+ if dataclasses.is_dataclass(value):
+ return _jsonable(dataclasses.asdict(value))
+ if isinstance(value, (str, int, float, bool)) or value is None:
+ return value
+ return str(value)
+
+
+def canonical_json(value: Any) -> bytes:
+ return json.dumps(_jsonable(value), sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+
+
+def sha256_bytes(value: bytes) -> str:
+ return hashlib.sha256(value).hexdigest()
+
+
+def _fingerprint_tensors(tensors: Iterator[tuple[str, torch.Tensor]]) -> str:
+ digest = hashlib.sha256()
+ for name, tensor in tensors:
+ value = tensor.detach().cpu().contiguous()
+ digest.update(name.encode("utf-8") + b"\0")
+ digest.update(str(value.dtype).encode("ascii") + b"\0")
+ digest.update(canonical_json(tuple(value.shape)))
+ digest.update(value.numpy().tobytes() if value.device.type == "cpu" else bytes(value))
+ return digest.hexdigest()
+
+
+def fingerprint_module(model: nn.Module) -> str:
+ return _fingerprint_tensors(iter(list(model.named_parameters()) + list(model.named_buffers())))
+
+
+def fingerprint_nonselected_state(model: nn.Module, selected_names: Sequence[str]) -> str:
+ excluded = set(selected_names)
+ return _fingerprint_tensors((name, tensor) for name, tensor in list(model.named_parameters()) + list(model.named_buffers()) if name not in excluded)
+
+
+def fingerprint_file(path: str | os.PathLike[str]) -> str:
+ digest = hashlib.sha256()
+ with Path(path).open("rb") as handle:
+ for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+ digest.update(chunk)
+ return digest.hexdigest()
+
+
+def fingerprint_paths(root: str | os.PathLike[str], paths: Sequence[str | os.PathLike[str]]) -> dict[str, str]:
+ base = Path(root).resolve()
+ result: dict[str, str] = {}
+ for item in paths:
+ path = Path(item)
+ if path.is_absolute():
+ full = path.resolve()
+ else:
+ cwd_relative = path.resolve()
+ full = (
+ cwd_relative
+ if base in cwd_relative.parents or cwd_relative == base
+ else (base / path).resolve()
+ )
+ if base not in full.parents and full != base:
+ raise SealError(f"artifact escapes run root: {item}")
+ if not full.is_file():
+ raise SealError(f"artifact is not a file: {full}")
+ result[str(full.relative_to(base))] = fingerprint_file(full)
+ return result
+
+
+def atomic_write_bytes(path: str | os.PathLike[str], data: bytes) -> Path:
+ destination = Path(path)
+ destination.parent.mkdir(parents=True, exist_ok=True)
+ fd, temporary = tempfile.mkstemp(prefix=f".{destination.name}.", dir=str(destination.parent))
+ try:
+ with os.fdopen(fd, "wb") as handle:
+ handle.write(data)
+ handle.flush()
+ os.fsync(handle.fileno())
+ os.replace(temporary, destination)
+ try:
+ directory_fd = os.open(destination.parent, os.O_RDONLY)
+ try:
+ os.fsync(directory_fd)
+ finally:
+ os.close(directory_fd)
+ except OSError:
+ pass
+ except Exception:
+ with contextlib.suppress(FileNotFoundError):
+ os.unlink(temporary)
+ raise
+ return destination
+
+
+def atomic_write_json(path: str | os.PathLike[str], value: Any) -> Path:
+ return atomic_write_bytes(path, canonical_json(value) + b"\n")
+
+
+@dataclasses.dataclass(frozen=True)
+class FrozenManifest:
+ protocol_version: str
+ config: Mapping[str, Any]
+ artifacts: Mapping[str, str]
+ manifest_hash: str
+ state: str = StudyState.FROZEN.value
+
+ def payload_without_hash(self) -> dict[str, Any]:
+ return {
+ "protocol_version": self.protocol_version,
+ "config": _jsonable(self.config),
+ "artifacts": dict(self.artifacts),
+ "state": self.state,
+ }
+
+ def to_dict(self) -> dict[str, Any]:
+ return {**self.payload_without_hash(), "manifest_hash": self.manifest_hash}
+
+
+_DEFER_MATRIX_FREEZE = False
+_MATRIX_CONFIRMING = False
+_DEFER_MATRIX_COMPLETION = False
+
+def freeze_run(
+ run_root: str | os.PathLike[str],
+ config: StudyConfig,
+ artifacts: Sequence[str | os.PathLike[str]],
+ state_machine: StudyStateMachine,
+) -> FrozenManifest:
+ state_machine.require(StudyState.DEVELOPING)
+ root = Path(run_root)
+ hashes = fingerprint_paths(root, artifacts)
+ provisional = {
+ "protocol_version": config.protocol_version,
+ "config": config.to_dict(),
+ "artifacts": hashes,
+ "state": StudyState.FROZEN.value,
+ }
+ manifest = FrozenManifest(config.protocol_version, config.to_dict(), hashes, sha256_bytes(canonical_json(provisional)))
+ if not _DEFER_MATRIX_FREEZE:
+ atomic_write_json(root / "frozen_manifest.json", manifest.to_dict())
+ state_machine.transition(StudyState.FROZEN)
+ return manifest
+
+
+def load_frozen_manifest(run_root: str | os.PathLike[str]) -> FrozenManifest:
+ path = Path(run_root) / "frozen_manifest.json"
+ try:
+ value = json.loads(path.read_text(encoding="utf-8"))
+ manifest = FrozenManifest(
+ protocol_version=value["protocol_version"],
+ config=value["config"],
+ artifacts=value["artifacts"],
+ manifest_hash=value["manifest_hash"],
+ state=value["state"],
+ )
+ except (OSError, KeyError, TypeError, ValueError) as exc:
+ raise SealError(f"invalid frozen manifest: {path}") from exc
+ if manifest.state != StudyState.FROZEN.value or manifest.protocol_version != PROTOCOL_VERSION:
+ raise SealError("frozen manifest has an invalid protocol or state")
+ expected = sha256_bytes(canonical_json(manifest.payload_without_hash()))
+ if expected != manifest.manifest_hash:
+ raise SealError("frozen manifest self-hash mismatch")
+ return manifest
+
+
+def verify_frozen_manifest(run_root: str | os.PathLike[str], manifest: FrozenManifest | None = None) -> FrozenManifest:
+ frozen = manifest or load_frozen_manifest(run_root)
+ actual = fingerprint_paths(run_root, tuple(frozen.artifacts.keys()))
+ if actual != dict(frozen.artifacts):
+ raise SealError("frozen artifact hash mismatch")
+ return frozen
+
+def load_state(run_root: str | os.PathLike[str]) -> StudyStateMachine:
+ path = Path(run_root) / "state.json"
+ try:
+ value = json.loads(path.read_text(encoding="utf-8"))
+ machine = StudyStateMachine(state=StudyState(value["state"]))
+ machine.history.extend(value.get("history", []))
+ machine.failure_reason = value.get("failure_reason")
+ return machine
+ except (OSError, KeyError, TypeError, ValueError) as exc:
+ raise StateTransitionError(f"invalid persisted state: {path}") from exc
+
+
+def publish_artifacts(
+ source_root: str | os.PathLike[str],
+ destination_root: str | os.PathLike[str],
+ paths: Sequence[str | os.PathLike[str]],
+) -> dict[str, str]:
+ """Copy already-produced evidence through atomic replaces and hash it."""
+ source = Path(source_root).resolve()
+ destination = Path(destination_root)
+ published: dict[str, str] = {}
+ for item in paths:
+ relative = Path(item)
+ if relative.is_absolute() or relative == Path(".") or ".." in relative.parts:
+ raise ProtocolError(f"publication path must be relative: {item}")
+ source_path = source / relative
+ if not source_path.is_file():
+ raise SealError(f"publication source is not a file: {source_path}")
+ data = source_path.read_bytes()
+ target = atomic_write_bytes(destination / relative, data)
+ published[str(relative)] = sha256_bytes(data)
+ if fingerprint_file(target) != published[str(relative)]:
+ raise SealError(f"published artifact hash mismatch: {target}")
+ return published
+
+
+def begin_confirmation(run_root: str | os.PathLike[str], state_machine: StudyStateMachine) -> FrozenManifest:
+ if _MATRIX_CONFIRMING and state_machine.state == StudyState.CONFIRMING:
+ return verify_frozen_manifest(run_root)
+ state_machine.require(StudyState.FROZEN)
+ manifest = verify_frozen_manifest(run_root)
+ state_machine.transition(StudyState.CONFIRMING)
+ return manifest
+
+
+def finish_confirmation(state_machine: StudyStateMachine, *, success: bool, reason: str | None = None) -> None:
+ state_machine.require(StudyState.CONFIRMING)
+ if success:
+ if not _DEFER_MATRIX_COMPLETION:
+ state_machine.transition(StudyState.COMPLETED)
+ else:
+ state_machine.fail(reason or "confirmation failed")
+
+
+def select_endpoint(
+ endpoints: Sequence[CandidateEndpoint],
+ validation_metric: Mapping[int, float],
+ *,
+ maximize: bool = False,
+) -> CandidateEndpoint:
+ if not endpoints:
+ raise ProtocolError("cannot select from empty endpoints")
+ ranked: list[tuple[float, int, CandidateEndpoint]] = []
+ for endpoint in endpoints:
+ value = validation_metric.get(endpoint.generation)
+ if value is None or not math.isfinite(float(value)):
+ raise ProtocolError(f"missing finite validation metric for generation {endpoint.generation}")
+ ranked.append(((-float(value) if maximize else float(value)), endpoint.generation, endpoint))
+ ranked.sort(key=lambda item: (item[0], item[1]))
+ return ranked[0][2]
+
+
+def prepare_run(run_root: str | os.PathLike[str], config: StudyConfig) -> StudyStateMachine:
+ root = Path(run_root)
+ root.mkdir(parents=True, exist_ok=True)
+ state = StudyStateMachine()
+ atomic_write_json(root / "config.json", config.to_dict())
+ atomic_write_json(root / "state.json", state.to_dict())
+ return state
+
+
+def persist_state(run_root: str | os.PathLike[str], state_machine: StudyStateMachine) -> None:
+ atomic_write_json(Path(run_root) / "state.json", state_machine.to_dict())
+
+
+def build_cli_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(description="Post-training ResNet/YOLO convergence protocol")
+ parser.add_argument("--phase", choices=["prepare", "smoke", "develop", "confirm", "publish", "all"], required=True)
+ parser.add_argument("--device", choices=["mps", "cpu"], default="cpu")
+ parser.add_argument("--data-root", type=Path, default=Path("result/cache"))
+ parser.add_argument("--run-root", type=Path, required=True)
+ parser.add_argument("--allow-download", action="store_true")
+ return parser
+
+
+def _make_adapters(config: StudyConfig, root: Path, data_root: Path, allow_download: bool) -> list[Any]:
+ if tuple(config.workload_ids) != DEFAULT_WORKLOAD_IDS:
+ raise ProtocolError("the main matrix must contain all three workloads in fixed order")
+ return [
+ get_workload(workload_id).adapter_factory(
+ workload_id=workload_id,
+ config=config,
+ run_root=root,
+ data_root=data_root,
+ device=config.device,
+ allow_download=allow_download,
+ )
+ for workload_id in config.workload_ids
+ ]
+
+
+_REQUIRED_RESULT_FIELDS = (
+ "workload_id", "family", "config", "manifests", "provenance", "baselines",
+ "arms", "ensemble", "development_selection", "confirmation", "integrity",
+ "leakage_counters", "resource_ledger", "artifact_hashes",
+)
+
+
+def _finite_record(value: Any) -> bool:
+ if isinstance(value, float):
+ return math.isfinite(value)
+ if isinstance(value, Mapping):
+ return all(_finite_record(item) for item in value.values())
+ if isinstance(value, (list, tuple)):
+ return all(_finite_record(item) for item in value)
+ return True
+
+
+def _completed_record(value: Any, label: str) -> None:
+ if not isinstance(value, Mapping) or not value:
+ raise SealError(f"missing completed record: {label}")
+ if not _finite_record(value):
+ raise SealError(f"non-finite record: {label}")
+ failures = value.get("failures")
+ if isinstance(failures, list) and failures:
+ raise SealError(f"failed evaluations in record: {label}")
+ if value.get("success") is False or value.get("completed") is False:
+ raise SealError(f"unsuccessful record: {label}")
+ numeric = _find_numeric(value, ("loss", "objective", "nll", "accuracy", "map", "metric", "queries"))
+ if numeric is None:
+ raise SealError(f"record has no finite completion metric: {label}")
+
+
+def _find_numeric(value: Any, keys: Sequence[str]) -> float | None:
+ if isinstance(value, Mapping):
+ for key, item in value.items():
+ if any(token in str(key).lower() for token in keys) and _finite_number(item):
+ return float(item)
+ found = _find_numeric(item, keys)
+ if found is not None:
+ return found
+ elif isinstance(value, (list, tuple)):
+ for item in value:
+ found = _find_numeric(item, keys)
+ if found is not None:
+ return found
+ return None
+
+
+def _arm_cells(arms: Mapping[str, Any], method: str) -> dict[tuple[int, int], Any]:
+ cells: dict[tuple[int, int], Any] = {}
+ method_tree = arms.get(method)
+ if isinstance(method_tree, Mapping):
+ for base_key, swarm_tree in method_tree.items():
+ if not str(base_key).isdigit() or not isinstance(swarm_tree, Mapping):
+ continue
+ for swarm_key, record in swarm_tree.items():
+ if str(swarm_key).isdigit():
+ cells[(int(base_key), int(swarm_key))] = record
+ for key, value in arms.items():
+ text = str(key)
+ if text.startswith(f"{method}/"):
+ parts = text.split("/")
+ if len(parts) == 3 and parts[1].isdigit() and parts[2].isdigit():
+ cells[(int(parts[1]), int(parts[2]))] = value
+ if text.isdigit() and isinstance(value, Mapping):
+ base = int(text)
+ for child_key, child in value.items():
+ child_text = str(child_key)
+ if child_text.startswith(f"{method}:") and child_text.split(":", 1)[1].isdigit():
+ swarm = int(child_text.split(":", 1)[1])
+ cells[(base, swarm)] = child.get(method, child) if isinstance(child, Mapping) else child
+ return cells
+
+
+def _control_cells(arms: Mapping[str, Any], method: str) -> dict[int, Any]:
+ cells: dict[int, Any] = {}
+ method_tree = arms.get(method)
+ if isinstance(method_tree, Mapping):
+ for base_key, record in method_tree.items():
+ if str(base_key).isdigit():
+ cells[int(base_key)] = record
+ for key, value in arms.items():
+ text = str(key)
+ if text.startswith(f"{method}/") and text.split("/")[-1].isdigit():
+ cells[int(text.split("/")[-1])] = value
+ if text.isdigit() and isinstance(value, Mapping) and method in value:
+ cells[int(text)] = value[method]
+ return cells
+
+
+def _saved_record_count(value: Any) -> int:
+ if isinstance(value, Mapping):
+ keys = {str(key).lower() for key in value}
+ if keys & {"predictions", "prediction", "metrics", "metric", "map50_95", "nll"}:
+ return 1
+ return sum(_saved_record_count(item) for item in value.values())
+ if isinstance(value, (list, tuple)):
+ return sum(_saved_record_count(item) for item in value)
+ return 0
+
+
+def _test_counter(result: Mapping[str, Any], token: str) -> int | None:
+ values: list[int] = []
+ def visit(value: Any) -> None:
+ if isinstance(value, Mapping):
+ for key, item in value.items():
+ lowered = str(key).lower()
+ if "test" in lowered and token in lowered and isinstance(item, int) and not isinstance(item, bool):
+ values.append(item)
+ visit(item)
+ elif isinstance(value, (list, tuple)):
+ for item in value:
+ visit(item)
+ visit(result.get("leakage_counters", {}))
+ return sum(values) if values else None
+
+
+def _validate_development_result(
+ workload_id: str,
+ result: Mapping[str, Any],
+) -> None:
+ baselines = result["baselines"]
+ if (
+ not isinstance(baselines, Mapping)
+ or set(map(str, baselines)) != set(map(str, BASE_SEEDS))
+ ):
+ raise SealError(
+ f"{workload_id}: baseline matrix must contain exactly "
+ "three base seeds"
+ )
+ for seed in BASE_SEEDS:
+ _completed_record(
+ baselines.get(str(seed)),
+ f"{workload_id}/baseline/{seed}",
+ )
+ arms = result["arms"]
+ if not isinstance(arms, Mapping):
+ raise SealError(f"{workload_id}: missing arms")
+ for method in ("feature_pso", "feature_random"):
+ cells = _arm_cells(arms, method)
+ expected = {
+ (base, swarm)
+ for base in BASE_SEEDS
+ for swarm in SWARM_SEEDS
+ }
+ if set(cells) != expected:
+ raise SealError(
+ f"{workload_id}: {method} matrix is incomplete"
+ )
+ for cell, record in cells.items():
+ _completed_record(
+ record,
+ f"{workload_id}/{method}/{cell[0]}/{cell[1]}",
+ )
+ for method in ("feature_adam", "head_adam"):
+ cells = _control_cells(arms, method)
+ if set(cells) != set(BASE_SEEDS):
+ raise SealError(
+ f"{workload_id}: {method} control matrix is incomplete"
+ )
+ for seed, record in cells.items():
+ _completed_record(
+ record,
+ f"{workload_id}/{method}/{seed}",
+ )
+ ensemble = result["ensemble"]
+ if not isinstance(ensemble, Mapping):
+ raise SealError(f"{workload_id}: missing ensemble records")
+ if result["family"] == "classification":
+ for method in (
+ "uniform",
+ "uniform_temperature",
+ "slsqp_weights",
+ ):
+ _completed_record(
+ ensemble.get(method),
+ f"{workload_id}/ensemble/{method}",
+ )
+ pso = ensemble.get("ensemble_pso")
+ if isinstance(pso, Mapping):
+ pso = pso.get("objective")
+ if not isinstance(pso, list) or len(pso) != len(SWARM_SEEDS):
+ raise SealError(
+ f"{workload_id}: ensemble PSO matrix is incomplete"
+ )
+ for seed, record in zip(SWARM_SEEDS, pso):
+ _completed_record(
+ record,
+ f"{workload_id}/ensemble_pso/{seed}",
+ )
+ else:
+ aliases = {
+ "uniform_wbf": ("uniform_wbf", "uniform"),
+ "ensemble_pso_wbf": (
+ "ensemble_pso_wbf",
+ "pso_wbf",
+ "ensemble_pso",
+ ),
+ "random_wbf": (
+ "random_wbf",
+ "feature_random_wbf",
+ "ensemble_random",
+ "random",
+ ),
+ }
+ for method, names in aliases.items():
+ records = next(
+ (ensemble[name] for name in names if name in ensemble),
+ None,
+ )
+ if method == "uniform_wbf":
+ _completed_record(
+ records,
+ f"{workload_id}/ensemble/{method}",
+ )
+ continue
+ if (
+ not isinstance(records, list)
+ or len(records) != len(SWARM_SEEDS)
+ ):
+ raise SealError(
+ f"{workload_id}: detection ensemble {method} "
+ "matrix is incomplete"
+ )
+ for seed, record in zip(SWARM_SEEDS, records):
+ _completed_record(
+ record,
+ f"{workload_id}/ensemble/{method}/{seed}",
+ )
+ if (
+ not isinstance(result["artifact_hashes"], Mapping)
+ or not result["artifact_hashes"]
+ ):
+ raise SealError(
+ f"{workload_id}: nonempty artifact hashes are required "
+ "before freezing"
+ )
+ if result["integrity"].get("official_test_opened") is not False:
+ raise SealError(
+ f"{workload_id}: official_test_opened must be false "
+ "before freezing"
+ )
+ if (
+ _test_counter(result, "construction") not in (None, 0)
+ or _test_counter(result, "forward") not in (None, 0)
+ ):
+ raise SealError(
+ f"{workload_id}: pre-freeze test exposure is nonzero"
+ )
+
+
+def _validate_matrix_results(root: Path, *, require_confirmation: bool = False, strict_development: bool = False) -> dict[str, dict[str, Any]]:
+ results: dict[str, dict[str, Any]] = {}
+ for workload_id in DEFAULT_WORKLOAD_IDS:
+ path = root / "workloads" / workload_id / "result.json"
+ if not path.is_file():
+ raise SealError(f"missing workload result: {path}")
+ try:
+ result = json.loads(path.read_text(encoding="utf-8"))
+ except (OSError, ValueError, json.JSONDecodeError) as exc:
+ raise SealError(f"invalid workload result: {path}") from exc
+ if not isinstance(result, dict) or any(field not in result for field in _REQUIRED_RESULT_FIELDS):
+ raise SealError(f"incomplete workload result: {workload_id}")
+ if result.get("workload_id") != workload_id:
+ raise SealError(f"workload result id mismatch: {workload_id}")
+ if not _finite_record(result):
+ raise SealError(f"non-finite workload result: {workload_id}")
+ if strict_development:
+ _validate_development_result(workload_id, result)
+ if require_confirmation:
+ confirmation = result["confirmation"]
+ family = result.get("family")
+ expected_confirmations = (
+ len(BASE_SEEDS) * 5 + 4
+ if family == "classification"
+ else len(BASE_SEEDS) * 5 + 3
+ )
+ if (
+ not isinstance(confirmation, Mapping)
+ or not confirmation
+ or _saved_record_count(confirmation) < expected_confirmations
+ ):
+ raise SealError(
+ f"{workload_id}: confirmation must contain every selected "
+ "frozen method record"
+ )
+ construction = _test_counter(result, "construction")
+ if construction != 1:
+ raise SealError(f"{workload_id}: official test construction must occur exactly once")
+ forwards = _test_counter(result, "forward")
+ evaluations = _test_counter(result, "evaluation")
+ if forwards is None and evaluations is None:
+ raise SealError(f"{workload_id}: declared test forward/evaluation counter is missing")
+ if (forwards or evaluations or 0) <= 0:
+ raise SealError(f"{workload_id}: test forward/evaluation counter must be positive")
+ for key, value in confirmation.items():
+ if any(token in str(key).lower() for token in ("repeat", "rerun", "tuning")) and value:
+ raise SealError(f"{workload_id}: confirmation contains repeat/tuning activity")
+ declared = result["artifact_hashes"]
+ if not isinstance(declared, Mapping):
+ raise SealError(f"invalid artifact hash map: {workload_id}")
+ for relative, expected in declared.items():
+ if not isinstance(relative, str) or not isinstance(expected, str):
+ raise SealError(f"invalid artifact hash entry: {workload_id}")
+ artifact = (root / relative).resolve()
+ if root.resolve() not in artifact.parents or not artifact.is_file() or fingerprint_file(artifact) != expected:
+ raise SealError(f"declared artifact hash drift: {relative}")
+ results[workload_id] = result
+ return results
+
+
+def _stable_matrix_artifacts(root: Path) -> list[str]:
+ if not (root / "config.json").is_file():
+ raise SealError("shared config.json is missing")
+ artifacts = ["config.json"]
+ if (root / "runtime_config.json").is_file():
+ artifacts.append("runtime_config.json")
+ for workload_id in DEFAULT_WORKLOAD_IDS:
+ workload_root = root / "workloads" / workload_id
+ if not workload_root.is_dir():
+ raise SealError(f"missing workload artifact directory: {workload_id}")
+ for path in sorted(workload_root.rglob("*")):
+ if (
+ path.is_file()
+ and not path.is_symlink()
+ and path.name not in {"result.json", "frozen_manifest.json"}
+ ):
+ artifacts.append(str(path.relative_to(root)))
+ return artifacts
+
+
+def _run_adapter_phase(adapters: Sequence[Any], phase: str) -> list[Any]:
+ outputs: list[Any] = []
+ for adapter in adapters:
+ runner = getattr(adapter, "run_phase", None)
+ if not callable(runner):
+ raise ProtocolError(f"adapter {type(adapter).__name__} lacks run_phase")
+ outputs.append(runner(phase))
+ return outputs
+
+def _run_adapter_development(
+ adapters: Sequence[Any],
+ root: Path,
+) -> list[Any]:
+ outputs: list[Any] = []
+ for adapter in adapters:
+ workload_root = root / "workloads" / str(adapter.workload_id)
+ marker_path = workload_root / "development_reuse.json"
+ if not marker_path.is_file():
+ outputs.extend(_run_adapter_phase((adapter,), "develop"))
+ continue
+ marker = json.loads(marker_path.read_text(encoding="utf-8"))
+ if (
+ marker.get("protocol_version") != PROTOCOL_VERSION
+ or not isinstance(marker.get("source_run"), str)
+ ):
+ raise SealError(
+ f"invalid development reuse marker: {marker_path}"
+ )
+ result_path = workload_root / "result.json"
+ result = json.loads(result_path.read_text(encoding="utf-8"))
+ if (
+ not isinstance(result, dict)
+ or any(
+ field not in result
+ for field in _REQUIRED_RESULT_FIELDS
+ )
+ or result.get("workload_id") != adapter.workload_id
+ or not _finite_record(result)
+ ):
+ raise SealError(
+ f"reused workload result is invalid: "
+ f"{workload_root.name}"
+ )
+ _validate_development_result(
+ str(adapter.workload_id),
+ result,
+ )
+ declared = result["artifact_hashes"]
+ for relative, expected in declared.items():
+ artifact = root / str(relative)
+ if (
+ not artifact.is_file()
+ or fingerprint_file(artifact) != expected
+ ):
+ raise SealError(
+ f"reused artifact hash drift: {relative}"
+ )
+ outputs.append(result)
+ return outputs
+
+
+def _run_matrix_phase(
+ phase: str,
+ *,
+ config: StudyConfig,
+ root: Path,
+ data_root: Path,
+ allow_download: bool,
+) -> Any:
+ global _DEFER_MATRIX_FREEZE, _MATRIX_CONFIRMING, _DEFER_MATRIX_COMPLETION
+ if phase == "prepare":
+ if (root / "state.json").is_file():
+ state = load_state(root)
+ state.require(StudyState.PREPARED)
+ else:
+ state = prepare_run(root, config)
+ outputs = _run_adapter_phase(_make_adapters(config, root, data_root, allow_download), "prepare")
+ _validate_matrix_results(root)
+ persist_state(root, state)
+ return outputs
+ state = load_state(root)
+ if phase == "smoke":
+ state.require(StudyState.PREPARED)
+ _validate_matrix_results(root)
+ outputs = _run_adapter_phase(_make_adapters(config, root, data_root, allow_download), "smoke")
+ for result in _validate_matrix_results(root).values():
+ leakage = result["leakage_counters"]
+ if any("test" in str(key).lower() and isinstance(value, int) and value != 0 for key, value in leakage.items()):
+ raise SealError("smoke opened official test data")
+ return outputs
+ if phase == "develop":
+ if state.state == StudyState.PREPARED:
+ state.transition(StudyState.DEVELOPING)
+ persist_state(root, state)
+ else:
+ state.require(StudyState.DEVELOPING)
+ _DEFER_MATRIX_FREEZE = True
+ try:
+ outputs = _run_adapter_development(
+ _make_adapters(
+ config,
+ root,
+ data_root,
+ allow_download,
+ ),
+ root,
+ )
+ finally:
+ _DEFER_MATRIX_FREEZE = False
+ _validate_matrix_results(root, strict_development=True)
+ for workload_id in DEFAULT_WORKLOAD_IDS:
+ workload_root = root / "workloads" / workload_id
+ atomic_write_bytes(
+ workload_root / "development_result.json",
+ (workload_root / "result.json").read_bytes(),
+ )
+ freeze_run(root, config, _stable_matrix_artifacts(root), state)
+ persist_state(root, state)
+ return outputs
+ if phase == "confirm":
+ state.require(StudyState.FROZEN)
+ verify_frozen_manifest(root)
+ state.transition(StudyState.CONFIRMING)
+ persist_state(root, state)
+ _MATRIX_CONFIRMING = True
+ _DEFER_MATRIX_COMPLETION = True
+ try:
+ outputs = _run_adapter_phase(_make_adapters(config, root, data_root, allow_download), "confirm")
+ finally:
+ _MATRIX_CONFIRMING = False
+ _DEFER_MATRIX_COMPLETION = False
+ verify_frozen_manifest(root)
+ _validate_matrix_results(root, require_confirmation=True, strict_development=True)
+ state.transition(StudyState.COMPLETED)
+ persist_state(root, state)
+ return outputs
+ if phase == "publish":
+ state.require(StudyState.COMPLETED)
+ verify_frozen_manifest(root)
+ return _publish_saved(root)
+ raise ProtocolError(f"unsupported matrix phase: {phase}")
+
+
+def _finite_number(value: Any) -> bool:
+ return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(float(value))
+
+
+def _plot_saved_trajectories(root: Path, destination: Path, workload_ids: Sequence[str]) -> Path:
+ try:
+ import matplotlib
+ matplotlib.use("Agg")
+ import matplotlib.pyplot as plt
+ except ImportError as exc:
+ raise ProtocolError("publish requires matplotlib to render saved trajectories") from exc
+ figure, axis = plt.subplots(figsize=(10, 5))
+ plotted = 0
+ for workload_id in workload_ids:
+ result = json.loads((root / "workloads" / workload_id / "result.json").read_text(encoding="utf-8"))
+ for name, record in result.get("arms", {}).items():
+ if not isinstance(record, Mapping) or not isinstance(record.get("trajectory"), list):
+ continue
+ points = [
+ (item.get("generation"), item.get("objective_best"))
+ for item in record["trajectory"]
+ if isinstance(item, Mapping)
+ and _finite_number(item.get("generation"))
+ and _finite_number(item.get("objective_best"))
+ ]
+ if points:
+ axis.plot([point[0] for point in points], [point[1] for point in points], alpha=0.7, label=f"{workload_id}:{name}")
+ plotted += 1
+ if not plotted:
+ axis.text(0.5, 0.5, "No trajectory data recorded", ha="center", va="center")
+ axis.set_title("Saved-data trajectory unavailable")
+ else:
+ axis.legend(fontsize=6, loc="best")
+ axis.set_xlabel("evaluated generation")
+ axis.set_ylabel("objective")
+ axis.grid(True, alpha=0.25)
+ figure.tight_layout()
+ temporary = tempfile.NamedTemporaryFile(prefix=".plot-", suffix=".png", delete=False)
+ temporary.close()
+ temporary_path = Path(temporary.name)
+ try:
+ figure.savefig(temporary_path, dpi=150)
+ atomic_write_bytes(destination, temporary_path.read_bytes())
+ finally:
+ plt.close(figure)
+ with contextlib.suppress(FileNotFoundError):
+ temporary_path.unlink()
+ return destination
+
+
+def _publish_saved(root: Path) -> dict[str, str]:
+ evaluator = importlib.import_module("test.evaluate_post_training_model_convergence")
+ evaluate = getattr(evaluator, "evaluate_run", None)
+ if not callable(evaluate):
+ raise ProtocolError("evaluator does not expose evaluate_run")
+ payload = evaluate(root)
+ if not isinstance(payload, Mapping):
+ raise ProtocolError("evaluator returned a non-object payload")
+ results = _validate_matrix_results(root, require_confirmation=True)
+ benchmark_root, plot_root = Path("benchmark_results"), Path("history_plt")
+ benchmark_root.mkdir(parents=True, exist_ok=True)
+ plot_root.mkdir(parents=True, exist_ok=True)
+ json_path = atomic_write_json(benchmark_root / "pso_v9_model_convergence.json", payload)
+ evaluation_path = atomic_write_json(benchmark_root / "pso_v9_model_convergence_evaluation.json", payload)
+ output = io.StringIO()
+ writer = __import__("csv").DictWriter(output, fieldnames=["workload_id", "family", "valid", "issue_count"])
+ writer.writeheader()
+ issue_count = sum(len(items) for items in payload.get("issues", {}).values()) if isinstance(payload.get("issues"), Mapping) else 0
+ for workload_id in DEFAULT_WORKLOAD_IDS:
+ finding = payload.get("workloads", {}).get(workload_id, {}) if isinstance(payload.get("workloads"), Mapping) else {}
+ writer.writerow({"workload_id": workload_id, "family": results[workload_id]["family"], "valid": finding.get("valid", False), "issue_count": issue_count})
+ csv_path = atomic_write_bytes(benchmark_root / "pso_v9_model_convergence.csv", output.getvalue().encode("utf-8"))
+ resnet_plot = _plot_saved_trajectories(root, plot_root / "pso_v9_resnet_convergence.png", DEFAULT_WORKLOAD_IDS[:2])
+ yolo_plot = _plot_saved_trajectories(root, plot_root / "pso_v9_yolo_convergence.png", DEFAULT_WORKLOAD_IDS[2:])
+ return {"json": str(json_path), "csv": str(csv_path), "evaluation": str(evaluation_path), "resnet_plot": str(resnet_plot), "yolo_plot": str(yolo_plot)}
+
+
+def run_phase(
+ phase: str,
+ *,
+ config: StudyConfig,
+ run_root: str | os.PathLike[str],
+ data_root: str | os.PathLike[str],
+ allow_download: bool = False,
+ adapter_runner: Callable[..., Any] | None = None,
+) -> Any:
+ root, data = Path(run_root), Path(data_root)
+ if adapter_runner is not None:
+ return adapter_runner(phase=phase, config=config, run_root=root, data_root=data, device=config.device, allow_download=allow_download)
+ if phase == "all":
+ return {current: _run_matrix_phase(current, config=config, root=root, data_root=data, allow_download=allow_download) for current in ("prepare", "smoke", "develop", "confirm", "publish")}
+ return _run_matrix_phase(phase, config=config, root=root, data_root=data, allow_download=allow_download)
+
+
+def _load_cli_config(args: argparse.Namespace) -> StudyConfig:
+ path = args.run_root / "config.json"
+ if args.phase not in {"prepare", "all"} and path.is_file():
+ config = StudyConfig.from_dict(json.loads(path.read_text(encoding="utf-8")))
+ if config.device != args.device and args.device != "cpu":
+ raise ProtocolError("requested device differs from the prepared run")
+ return config
+ return StudyConfig(device=args.device)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+ args = build_cli_parser().parse_args(argv)
+ try:
+ result = run_phase(args.phase, config=_load_cli_config(args), run_root=args.run_root, data_root=args.data_root, allow_download=args.allow_download)
+ if isinstance(result, Mapping):
+ print(json.dumps(_jsonable(result), sort_keys=True, separators=(",", ":")))
+ return 0
+ except (ProtocolError, SealError, StateTransitionError, ObjectiveEvaluationError, RuntimeError, OSError) as exc:
+ try:
+ state = load_state(args.run_root)
+ if state.state not in {StudyState.COMPLETED, StudyState.FAILED}:
+ state.fail(f"{args.phase} failed: {type(exc).__name__}: {exc}")
+ persist_state(args.run_root, state)
+ except (OSError, StateTransitionError, ProtocolError):
+ pass
+ try:
+ atomic_write_json(args.run_root / "failure.json", {"phase": args.phase, "error": f"{type(exc).__name__}: {exc}"})
+ except OSError:
+ pass
+ return 2
+
+
+__all__ = [
+ "AuditCallback", "AuditResult", "BASE_SEEDS", "BOOTSTRAP_SEED", "CandidateEndpoint",
+ "DEFAULT_WORKLOAD_IDS", "FrozenManifest", "INITIAL_RADIUS", "ObjectiveCallback", "ObjectiveEvaluationError",
+ "ObjectiveResult", "PARTICLE_COUNT", "PROJECTION_SEED", "ProtocolError", "PSO_GENERATIONS", "RANDOM_CANDIDATES",
+ "RESIDUAL_BOUND", "RESIDUAL_DIMENSION", "ResourceCounters", "RunState", "SWARM_SEEDS", "SPLIT_SEED",
+ "SealError", "SearchResult", "SelectedResidualCodec", "StateTransitionError", "StudyConfig", "StudyState",
+ "StudyStateMachine", "WorkloadSpec", "atomic_write_bytes", "atomic_write_json", "begin_confirmation",
+ "build_cli_parser", "canonical_json", "fingerprint_file", "fingerprint_module", "fingerprint_nonselected_state",
+ "fingerprint_paths", "finish_confirmation", "freeze_run", "get_workload", "load_frozen_manifest", "load_state", "main",
+ "prepare_run", "projection_salt", "publish_artifacts", "register_workload", "registered_workloads", "run_equal_budget_random",
+ "run_phase", "run_random_search", "run_residual_pso", "run_state_neutral_audit", "select_endpoint",
+ "sha256_bytes", "state_neutral_audit", "verify_frozen_manifest",
+]
+
+
+if __name__ == "__main__":
+ import sys
+ sys.modules.setdefault("test.post_training_model_convergence", sys.modules[__name__])
+ raise SystemExit(main())
diff --git a/test/post_training_pso_ensemble.py b/test/post_training_pso_ensemble.py
new file mode 100755
index 0000000..d47f4c4
--- /dev/null
+++ b/test/post_training_pso_ensemble.py
@@ -0,0 +1,1751 @@
+#!/usr/bin/env python3
+"""
+Post-Training PSO Ensemble Study Runner
+
+Determines whether PSO is useful and efficient after ordinary backpropagation by
+optimizing prediction-space ensemble weights for independently Adam-trained CNNs.
+
+Key Invariants:
+1. Development source: only each dataset's official train=True 60,000 examples.
+2. Stratified split: 50,000 search / 10,000 validation with split seed 20260904.
+3. Normalization: mean and std fitted on search split only (unrounded).
+4. Model: CompactCNN (9,098 parameters).
+5. Pool seeds: 201, 202, 203, 204, 205.
+6. Baseline single_50e: seed 201 captured at epoch 10 and continued to epoch 50.
+7. Optimization methods: reference_single_10e, best_single_10e, single_50e,
+ uniform_ensemble, uniform_temperature, slsqp_weights, pso_weights.
+8. Official test dataset (train=False) loaded only after development gates pass.
+9. Trained models retained in memory and reused for official test without retraining.
+10. Atomic writes via unique same-directory temporary files + os.replace.
+"""
+
+import argparse
+import copy
+import hashlib
+import json
+import math
+import os
+import sys
+import time
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import scipy.optimize
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.model_selection import train_test_split
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+# Ensure repository root is in sys.path
+repo_root = Path(__file__).resolve().parent.parent
+if str(repo_root) not in sys.path:
+ sys.path.insert(0, str(repo_root))
+
+from pso.optimizer import Optimizer, resolve_device
+
+
+PROTOCOL_VERSION = "POST-TRAINING-PSO-ENSEMBLE 1.1.0"
+
+
+def sync_device(device: Optional[Union[str, torch.device]] = None):
+ dev = resolve_device(device)
+ if dev.type == "cuda":
+ torch.cuda.synchronize(dev)
+ elif dev.type == "mps" and hasattr(torch, "mps") and hasattr(torch.mps, "synchronize"):
+ torch.mps.synchronize()
+
+
+# =====================================================================
+# 1. Architecture: CompactCNN (9,098 Parameters)
+# =====================================================================
+
+class CompactCNN(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.conv1 = nn.Conv2d(1, 8, kernel_size=3, padding=1)
+ self.relu1 = nn.ReLU()
+ self.pool1 = nn.MaxPool2d(2, 2)
+ self.conv2 = nn.Conv2d(8, 16, kernel_size=3, padding=1)
+ self.relu2 = nn.ReLU()
+ self.pool2 = nn.MaxPool2d(2, 2)
+ self.flatten = nn.Flatten()
+ self.fc = nn.Linear(784, 10)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ if x.dim() == 2 and x.shape[1] == 784:
+ x = x.view(-1, 1, 28, 28)
+ out = self.pool1(self.relu1(self.conv1(x)))
+ out = self.pool2(self.relu2(self.conv2(out)))
+ out = self.flatten(out)
+ return self.fc(out)
+
+
+def compute_model_fingerprint(model: nn.Module) -> str:
+ h = hashlib.sha256()
+ for p in model.parameters():
+ h.update(p.detach().cpu().numpy().tobytes())
+ return h.hexdigest()[:16]
+
+
+# =====================================================================
+# 2. PyTorch Softmax Weight Wrapper over Cached Member Probabilities
+# =====================================================================
+
+class CachedProbabilityEnsemble(nn.Module):
+ """
+ PyTorch module parameterizing ensemble weights via a softmax vector over M member probabilities.
+ Exposes raw_weights parameter optimized by public pso.Optimizer.
+ Returns normalized log probabilities for nn.NLLLoss evaluation.
+ Member probabilities input has shape (N, M, K).
+ """
+ def __init__(self, num_members: int = 5, init_weights: Optional[torch.Tensor] = None):
+ super().__init__()
+ self.num_members = num_members
+ if init_weights is not None:
+ if init_weights.shape != (num_members,):
+ raise ValueError(f"init_weights must have shape ({num_members},)")
+ self.raw_weights = nn.Parameter(init_weights.clone().float())
+ else:
+ self.raw_weights = nn.Parameter(torch.zeros(num_members, dtype=torch.float32))
+
+ def weights(self) -> torch.Tensor:
+ return F.softmax(self.raw_weights, dim=0)
+
+ def forward(self, member_probabilities: torch.Tensor) -> torch.Tensor:
+ """
+ member_probabilities: canonical tensor of shape (N, M, K)
+ Returns log probabilities of shape (N, K)
+ """
+ if member_probabilities.dim() != 3:
+ raise ValueError("member_probabilities must be a 3D tensor")
+ if member_probabilities.shape[1] != self.num_members:
+ raise ValueError(
+ "member_probabilities must use canonical (N, M, K) orientation "
+ f"with M={self.num_members}, got {tuple(member_probabilities.shape)}"
+ )
+
+ w = self.weights().view(1, -1, 1)
+ mix = torch.sum(w * member_probabilities, dim=1)
+ return torch.log(torch.clamp(mix, min=1e-12))
+
+
+# =====================================================================
+# 3. Probability Cache & Metric Utilities
+# =====================================================================
+
+def validate_probability_cache(probabilities: Union[torch.Tensor, np.ndarray]) -> bool:
+ if isinstance(probabilities, torch.Tensor):
+ arr = probabilities.detach().cpu().numpy()
+ else:
+ arr = np.asarray(probabilities)
+
+ if arr.ndim != 3:
+ return False
+
+ if arr.shape[0] == 0 or arr.shape[1] == 0:
+ return False
+
+ if arr.shape[2] < 2:
+ return False
+
+ if not np.all(np.isfinite(arr)):
+ return False
+
+ if np.any(arr < -1e-6) or np.any(arr > 1.0 + 1e-6):
+ return False
+
+ row_sums = arr.sum(axis=-1)
+ if not np.allclose(row_sums, 1.0, atol=1e-4):
+ return False
+
+ return True
+
+
+def mixture_probabilities(
+ weights: Union[torch.Tensor, np.ndarray],
+ member_probabilities: Union[torch.Tensor, np.ndarray],
+) -> Union[torch.Tensor, np.ndarray]:
+ if isinstance(weights, torch.Tensor):
+ w_np = weights.detach().cpu().numpy()
+ else:
+ w_np = np.asarray(weights, dtype=np.float64)
+
+ if not np.all(np.isfinite(w_np)):
+ raise ValueError("weights contain non-finite values")
+ if np.any(w_np < -1e-6):
+ raise ValueError("weights contain negative values")
+ w_sum = float(w_np.sum())
+ if w_sum <= 0:
+ raise ValueError("weights sum to zero or negative")
+
+ if not validate_probability_cache(member_probabilities):
+ raise ValueError("member_probabilities fails validate_probability_cache")
+
+ is_torch = isinstance(member_probabilities, torch.Tensor)
+ if member_probabilities.shape[0] != len(w_np):
+ raise ValueError(
+ "member_probabilities must use canonical (M, N, K) orientation "
+ f"with M={len(w_np)}, got {tuple(member_probabilities.shape)}"
+ )
+
+ if is_torch:
+ w = torch.as_tensor(
+ weights,
+ dtype=member_probabilities.dtype,
+ device=member_probabilities.device,
+ )
+ w = w / w.sum()
+ return torch.sum(w.view(-1, 1, 1) * member_probabilities, dim=0)
+
+ w = np.asarray(weights, dtype=np.float64)
+ w = w / w.sum()
+ probs = np.asarray(member_probabilities, dtype=np.float64)
+ return np.sum(w[:, None, None] * probs, axis=0)
+
+
+def probabilistic_metrics(
+ probabilities: Union[torch.Tensor, np.ndarray],
+ targets: Union[torch.Tensor, np.ndarray],
+) -> Dict[str, float]:
+ if isinstance(probabilities, torch.Tensor):
+ probs = probabilities.detach().cpu().numpy()
+ else:
+ probs = np.asarray(probabilities, dtype=np.float64)
+
+ if isinstance(targets, torch.Tensor):
+ labels = targets.detach().cpu().numpy()
+ else:
+ labels = np.asarray(targets, dtype=np.int64)
+
+ if probs.ndim != 2:
+ raise ValueError(f"probabilities must be 2D array, got shape {probs.shape}")
+
+ N, K = probs.shape
+ if labels.ndim != 1 or len(labels) != N:
+ raise ValueError(f"targets must be 1D array of length N={N}, got shape {labels.shape}")
+
+ if not np.all(np.isfinite(probs)):
+ raise ValueError("probabilities contain non-finite values")
+
+ if np.any(labels < 0) or np.any(labels >= K):
+ raise ValueError(f"targets must contain integers in range [0, {K-1}]")
+
+ row_sums = probs.sum(axis=1)
+ if not np.allclose(row_sums, 1.0, atol=1e-3):
+ raise ValueError("probabilities rows must sum to 1.0")
+
+ preds = probs.argmax(axis=1)
+ acc = float((preds == labels).mean()) * 100.0
+
+ eps = 1e-12
+ clipped = np.clip(probs, eps, 1.0 - eps)
+ nll = -float(np.log(clipped[np.arange(N), labels]).mean())
+
+ y_onehot = np.zeros((N, K), dtype=np.float64)
+ y_onehot[np.arange(N), labels] = 1.0
+ brier = float(np.mean(np.sum((probs - y_onehot) ** 2, axis=1)))
+
+ n_bins = 15
+ bin_boundaries = np.linspace(0.0, 1.0, n_bins + 1)
+ confidences = probs.max(axis=1)
+ ece = 0.0
+
+ for i in range(n_bins):
+ bin_lower = bin_boundaries[i]
+ bin_upper = bin_boundaries[i + 1]
+ in_bin = (confidences > bin_lower) & (confidences <= bin_upper) if i > 0 else (confidences >= bin_lower) & (confidences <= bin_upper)
+ prop = in_bin.mean()
+ if prop > 0:
+ accuracy_in_bin = (preds[in_bin] == labels[in_bin]).mean()
+ avg_conf = confidences[in_bin].mean()
+ ece += np.abs(accuracy_in_bin - avg_conf) * prop
+
+ sorted_probs = np.sort(probs, axis=1)[:, ::-1]
+ margins = sorted_probs[:, 0] - sorted_probs[:, 1]
+ margin_mean = float(margins.mean())
+
+ return {
+ "accuracy": round(acc, 4),
+ "nll": round(nll, 6),
+ "brier": round(brier, 6),
+ "ece": round(float(ece), 6),
+ "margin": round(margin_mean, 6),
+ }
+
+
+evaluate_probabilistic_metrics = probabilistic_metrics
+
+
+def temp_scaled_probs(uniform_probs: np.ndarray, temp: float) -> np.ndarray:
+ eps = 1e-12
+ log_p = np.log(np.clip(uniform_probs, eps, 1.0))
+ scaled_log_p = log_p / temp
+ max_log_p = np.max(scaled_log_p, axis=1, keepdims=True)
+ exp_p = np.exp(scaled_log_p - max_log_p)
+ return exp_p / np.sum(exp_p, axis=1, keepdims=True)
+
+
+def fit_uniform_temperature(uniform_probs: np.ndarray, targets: np.ndarray) -> Tuple[float, Dict[str, Any]]:
+ eval_count = 0
+ def obj(t: float) -> float:
+ nonlocal eval_count
+ eval_count += 1
+ p = temp_scaled_probs(uniform_probs, t)
+ return probabilistic_metrics(p, targets)["nll"]
+
+ t0 = time.perf_counter()
+ res = scipy.optimize.minimize_scalar(obj, bounds=(0.01, 10.0), method="bounded")
+ wall_t = time.perf_counter() - t0
+
+ if not res.success or not math.isfinite(res.x) or res.x <= 0:
+ raise RuntimeError(f"Temperature scaling optimization failed: success={res.success}, x={res.x}")
+
+ best_t = float(res.x)
+ best_probs = temp_scaled_probs(uniform_probs, best_t)
+ metrics = probabilistic_metrics(best_probs, targets)
+
+ temp_record = {
+ "fitted_temperature": round(best_t, 6),
+ "wall_time_seconds": float(wall_t),
+ "evaluations": int(eval_count),
+ "metrics": metrics,
+ }
+ return best_t, temp_record
+
+
+# =====================================================================
+# 4. SLSQP Solver with Analytical Simplex NLL Gradient
+# =====================================================================
+
+def simplex_nll_and_grad(
+ weights: np.ndarray,
+ member_probabilities: np.ndarray,
+ targets: np.ndarray,
+) -> Tuple[float, np.ndarray]:
+ """
+ Calculate validation NLL and its analytical gradient.
+
+ `member_probabilities` has one canonical orientation: (M, N, K).
+ """
+ w = np.asarray(weights, dtype=np.float64)
+ probs_mnk = np.asarray(member_probabilities, dtype=np.float64)
+ labels = np.asarray(targets, dtype=np.int64)
+ if not np.all(np.isfinite(w)):
+ raise ValueError("Weights contain non-finite values")
+ if probs_mnk.ndim != 3:
+ raise ValueError(
+ f"member_probabilities must be 3D array, got {probs_mnk.ndim}D"
+ )
+
+ M, N, _ = probs_mnk.shape
+ if len(w) != M:
+ raise ValueError(f"Weights length {len(w)} does not match num_members M={M}")
+ if labels.ndim != 1 or len(labels) != N:
+ raise ValueError(
+ "member_probabilities must use canonical (M, N, K) orientation "
+ f"with target count N={len(labels)}, got {probs_mnk.shape}"
+ )
+
+ mix_p = np.sum(w[:, None, None] * probs_mnk, axis=0)
+ p_true = mix_p[np.arange(N), labels]
+ p_true_clamped = np.maximum(p_true, 1e-12)
+ nll = -float(np.mean(np.log(p_true_clamped)))
+
+ P_true = probs_mnk[
+ np.arange(M)[:, None],
+ np.arange(N)[None, :],
+ labels[None, :],
+ ]
+ grad = -np.mean(P_true / p_true_clamped[None, :], axis=1)
+ return nll, grad
+
+
+def optimize_slsqp_weights(
+ member_probabilities: np.ndarray,
+ targets: np.ndarray,
+) -> Dict[str, Any]:
+ probs_mnk = np.asarray(member_probabilities, dtype=np.float64)
+ labels = np.asarray(targets, dtype=np.int64)
+ if probs_mnk.ndim != 3:
+ raise ValueError(
+ f"member_probabilities must be 3D array, got {probs_mnk.ndim}D"
+ )
+
+ M, N, _ = probs_mnk.shape
+ if labels.ndim != 1 or len(labels) != N:
+ raise ValueError(
+ "member_probabilities must use canonical (M, N, K) orientation "
+ f"with target count N={len(labels)}, got {probs_mnk.shape}"
+ )
+
+ w0 = np.full(M, 1.0 / M, dtype=np.float64)
+ bounds = [(0.0, 1.0)] * M
+ constraints = {'type': 'eq', 'fun': lambda w: np.sum(w) - 1.0, 'jac': lambda w: np.ones_like(w)}
+
+ eval_count = 0
+ def obj_func(w):
+ nonlocal eval_count
+ eval_count += 1
+ return simplex_nll_and_grad(w, probs_mnk, labels)
+
+ start_t = time.perf_counter()
+ res = scipy.optimize.minimize(
+ fun=obj_func,
+ x0=w0,
+ method="SLSQP",
+ jac=True,
+ bounds=bounds,
+ constraints=constraints,
+ options={'ftol': 1e-12, 'maxiter': 1000},
+ )
+ wall_t = time.perf_counter() - start_t
+
+ raw_w = np.maximum(res.x, 0.0)
+ sum_w = raw_w.sum()
+ norm_w = raw_w / sum_w if sum_w > 0 else np.full(M, 1.0 / M)
+
+ mix_probs = mixture_probabilities(norm_w, probs_mnk)
+ metrics = probabilistic_metrics(mix_probs, labels)
+
+ return {
+ "weights": norm_w.tolist(),
+ "evaluations": int(eval_count),
+ "wall_time_seconds": float(wall_t),
+ "success": bool(res.success),
+ "message": str(res.message),
+ "metrics": metrics,
+ }
+
+
+# =====================================================================
+# 5. Public PSO Optimizer Wrapper over Ensemble Weights
+# =====================================================================
+
+def run_pso_weights(
+ member_probabilities: Union[torch.Tensor, np.ndarray],
+ targets: Union[torch.Tensor, np.ndarray],
+ swarm_seeds: Optional[List[int]] = None,
+ particles: int = 30,
+ epochs: int = 30,
+ device: Optional[str] = None,
+) -> Dict[str, Any]:
+ if swarm_seeds is None:
+ swarm_seeds = [301, 302, 303]
+
+ if isinstance(member_probabilities, np.ndarray):
+ probs_t = torch.from_numpy(member_probabilities).float()
+ else:
+ probs_t = member_probabilities.float()
+
+ if isinstance(targets, np.ndarray):
+ targets_t = torch.from_numpy(targets).long()
+ else:
+ targets_t = targets.long()
+
+ if device is None:
+ dev = resolve_device()
+ else:
+ dev = torch.device(device)
+
+ if probs_t.dim() != 3:
+ raise ValueError(
+ f"member_probabilities must be 3D tensor, got {probs_t.dim()}D"
+ )
+
+ M, N, _ = probs_t.shape
+ if targets_t.dim() != 1 or len(targets_t) != N:
+ raise ValueError(
+ "member_probabilities must use canonical (M, N, K) orientation "
+ f"with target count N={len(targets_t)}, got {tuple(probs_t.shape)}"
+ )
+ probs_mnk = probs_t.contiguous()
+ probs_nmk = probs_mnk.permute(1, 0, 2).contiguous()
+
+ N, M, K = probs_nmk.shape
+ probs_dev = probs_nmk.to(dev)
+ targets_dev = targets_t.to(dev)
+
+ queries_per_seed = particles * epochs
+ sample_evaluations_per_seed = particles * epochs * N
+
+ per_seed_runs = []
+ best_nll = float('inf')
+ selected_seed = swarm_seeds[0]
+ selected_weights = [1.0 / M] * M
+ selected_metrics: Dict[str, float] = {}
+
+ for seed in swarm_seeds:
+ model = CachedProbabilityEnsemble(num_members=M).to(dev)
+ nn.init.zeros_(model.raw_weights)
+
+ loss_fn = nn.NLLLoss()
+ opt = Optimizer(
+ model=model,
+ loss=loss_fn,
+ task="multiclass",
+ method="constriction",
+ evaluation="full",
+ n_particles=particles,
+ particle_min=-4.0,
+ particle_max=4.0,
+ boundary_strategy="reflect",
+ velocity_limit_ratio=0.1,
+ initialization="model_noise",
+ initial_position_noise=0.0,
+ seed=seed,
+ device=dev,
+ )
+
+ sync_device(dev)
+ start_t = time.perf_counter()
+ opt.fit(probs_dev, targets_dev, epochs=epochs, renewal="loss")
+ sync_device(dev)
+ wall_t = time.perf_counter() - start_t
+
+ # Retrieve optimized weights from opt.get_best_model().weights(), never opt.model
+ best_model = opt.get_best_model()
+ weights_tensor = best_model.weights().detach().cpu()
+ weights_list = weights_tensor.numpy().tolist()
+
+ mix_p = mixture_probabilities(weights_tensor, probs_mnk)
+ metrics = probabilistic_metrics(mix_p, targets_t)
+
+ run_rec = {
+ "seed": seed,
+ "queries": queries_per_seed,
+ "sample_evaluations": sample_evaluations_per_seed,
+ "wall_time_seconds": float(wall_t),
+ "metrics": metrics,
+ "weights": weights_list,
+ }
+ per_seed_runs.append(run_rec)
+
+ if metrics["nll"] < best_nll:
+ best_nll = metrics["nll"]
+ selected_seed = seed
+ selected_weights = weights_list
+ selected_metrics = metrics
+
+ wall_times = [r["wall_time_seconds"] for r in per_seed_runs]
+ median_wall = float(np.median(wall_times))
+ total_wall = float(np.sum(wall_times))
+
+ return {
+ "per_seed_runs": per_seed_runs,
+ "selected_seed": selected_seed,
+ "selected_weights": selected_weights,
+ "metrics": selected_metrics,
+ "queries_per_seed": queries_per_seed,
+ "sample_evaluations_per_seed": sample_evaluations_per_seed,
+ "total_queries": queries_per_seed * len(swarm_seeds),
+ "total_sample_evaluations": sample_evaluations_per_seed * len(swarm_seeds),
+ "median_one_seed_wall_time_seconds": median_wall,
+ "total_wall_time_seconds": total_wall,
+ }
+
+
+# =====================================================================
+# 6. Data Preparation (Strict Train=True Only During Development)
+# =====================================================================
+
+def prepare_dataset_splits(
+ dataset_name: str,
+ split_seed: int = 20260904,
+ cache_dir: Optional[Path] = None,
+) -> Tuple[
+ torch.Tensor, torch.Tensor,
+ torch.Tensor, torch.Tensor,
+ Dict[str, Any]
+]:
+ """
+ Constructs 50,000 search split and 10,000 validation split using exclusively train=True.
+ Fits mean and std on search split only (unrounded). Never constructs train=False.
+ """
+ if cache_dir is None:
+ cache_dir = Path("result/cache")
+ cache_dir.mkdir(parents=True, exist_ok=True)
+
+ ds_lower = dataset_name.lower()
+ if ds_lower == "mnist":
+ from torchvision.datasets import MNIST
+ raw_train = MNIST(root=str(cache_dir), train=True, download=True)
+ canonical_name = "MNIST"
+ elif ds_lower in ("fashion_mnist", "fashion"):
+ from torchvision.datasets import FashionMNIST
+ raw_train = FashionMNIST(root=str(cache_dir), train=True, download=True)
+ canonical_name = "FashionMNIST"
+ else:
+ raise ValueError(f"Unsupported dataset name: '{dataset_name}'")
+
+ x_train_raw = raw_train.data.float() / 255.0 # (60000, 28, 28)
+ y_train_raw = raw_train.targets.long()
+
+ indices = np.arange(len(y_train_raw))
+ search_idx, val_idx = train_test_split(
+ indices,
+ train_size=50000,
+ test_size=10000,
+ stratify=y_train_raw.numpy(),
+ random_state=split_seed,
+ )
+
+ x_search_raw = x_train_raw[search_idx]
+ y_search = y_train_raw[search_idx]
+ x_val_raw = x_train_raw[val_idx]
+ y_val = y_train_raw[val_idx]
+
+ mean_val = float(x_search_raw.mean())
+ std_val = float(x_search_raw.std())
+
+ x_search_norm = ((x_search_raw - mean_val) / std_val).unsqueeze(1)
+ x_val_norm = ((x_val_raw - mean_val) / std_val).unsqueeze(1)
+
+ h_data = hashlib.sha256()
+ for t in (x_search_norm, x_val_norm, y_search, y_val):
+ h_data.update(t.detach().cpu().numpy().tobytes())
+ data_fp = h_data.hexdigest()[:16]
+
+ h_split = hashlib.sha256()
+ h_split.update(search_idx.tobytes())
+ h_split.update(val_idx.tobytes())
+ split_fp = h_split.hexdigest()[:16]
+
+ provenance = {
+ "dataset_name": canonical_name,
+ "split_seed": split_seed,
+ "search_samples": 50000,
+ "validation_samples": 10000,
+ "normalization": {"mean": mean_val, "std": std_val},
+ "data_fingerprint": data_fp,
+ "split_fingerprint": split_fp,
+ }
+
+ return x_search_norm, y_search, x_val_norm, y_val, provenance
+
+
+def load_official_test_data(
+ dataset_name: str,
+ mean_val: float,
+ std_val: float,
+ cache_dir: Optional[Path] = None,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+ """
+ Deferred test loader called exclusively after all development gates pass.
+ Uses exact unrounded normalization parameters fitted on search split.
+ """
+ if cache_dir is None:
+ cache_dir = Path("result/cache")
+
+ ds_lower = dataset_name.lower()
+ if ds_lower == "mnist":
+ from torchvision.datasets import MNIST
+ raw_test = MNIST(root=str(cache_dir), train=False, download=True)
+ elif ds_lower in ("fashion_mnist", "fashion"):
+ from torchvision.datasets import FashionMNIST
+ raw_test = FashionMNIST(root=str(cache_dir), train=False, download=True)
+ else:
+ raise ValueError(f"Unsupported dataset name: '{dataset_name}'")
+
+ x_test_raw = raw_test.data.float() / 255.0
+ y_test = raw_test.targets.long()
+ x_test_norm = ((x_test_raw - mean_val) / std_val).unsqueeze(1)
+ return x_test_norm, y_test
+
+
+def get_model_probabilities(
+ model: nn.Module,
+ x_data: torch.Tensor,
+ device: torch.device,
+ batch_size: int = 1000,
+) -> Tuple[torch.Tensor, float]:
+ model.eval()
+ model.to(device)
+ probs_list = []
+ sync_device(device)
+ t0 = time.perf_counter()
+ with torch.no_grad():
+ for i in range(0, len(x_data), batch_size):
+ batch_x = x_data[i:i+batch_size].to(device)
+ logits = model(batch_x)
+ probs = F.softmax(logits, dim=1)
+ probs_list.append(probs.cpu())
+ sync_device(device)
+ wall_t = time.perf_counter() - t0
+ res_t = torch.cat(probs_list, dim=0)
+ return res_t, wall_t
+
+
+# =====================================================================
+# 7. Development Gate Evaluator
+# =====================================================================
+
+def evaluate_development_gates(workloads_data: Dict[str, Any]) -> Dict[str, Any]:
+ gate_results = {}
+ issues = []
+
+ # 1. All values finite & valid simplex weights
+ finite_ok = True
+ simplex_ok = True
+ for wl_id, wl in workloads_data.items():
+ methods = wl["validation"]["methods"]
+ for m_name, m_val in methods.items():
+ if m_name in ("pso_weights", "slsqp_weights", "uniform_temperature"):
+ mets = m_val["metrics"]
+ else:
+ mets = m_val
+ for k, v in mets.items():
+ if not math.isfinite(v):
+ finite_ok = False
+ issues.append(f"{wl_id} {m_name} metric {k}={v} non-finite")
+
+ slsqp_w = np.array(methods["slsqp_weights"]["weights"])
+ pso_w = np.array(methods["pso_weights"]["selected_weights"])
+ for name, w in [("slsqp", slsqp_w), ("pso", pso_w)]:
+ if np.any(w < -1e-6) or not math.isclose(np.sum(w), 1.0, abs_tol=1e-6):
+ simplex_ok = False
+ issues.append(f"{wl_id} {name} weights {w} invalid simplex")
+
+ gate_results["all_values_finite"] = finite_ok and simplex_ok
+
+ # 2. Validation pool forward passes = 5
+ fwd_ok = all(
+ wl["validation_cache"]["pool_forward_passes"] == 5
+ for wl in workloads_data.values()
+ )
+ gate_results["validation_pool_forward_passes_exact"] = fwd_ok
+
+ # 3. Optimization base model forward passes = 0
+ base_fwd_ok = all(
+ wl["validation_cache"]["base_cnn_forward_passes_during_optimization"] == 0
+ for wl in workloads_data.values()
+ )
+ gate_results["optimization_base_model_forward_passes"] = base_fwd_ok
+
+ # 4. Official test data loaded before freeze = False and evals = 0
+ test_leak_ok = all(
+ not wl.get("official_test_data_loaded_before_freeze", False) and
+ wl.get("official_test_evaluations_before_freeze", 0) == 0
+ for wl in workloads_data.values()
+ )
+ gate_results["official_test_data_loaded_before_freeze"] = test_leak_ok
+
+ # 5. SLSQP solver success
+ slsqp_success_ok = all(
+ wl["validation"]["methods"]["slsqp_weights"]["success"]
+ for wl in workloads_data.values()
+ )
+ if not slsqp_success_ok:
+ issues.append("SLSQP solver failed on one or more workloads")
+ gate_results["slsqp_solver_success"] = slsqp_success_ok
+
+ # 6. Exact query and sample accounting (900 queries, 9,000,000 samples per seed for Iteration 1)
+ acct_ok = True
+ for wl_id, wl in workloads_data.items():
+ pso_rec = wl["validation"]["methods"]["pso_weights"]
+ for r in pso_rec["per_seed_runs"]:
+ if r["queries"] != 900 or r["sample_evaluations"] != 9000000:
+ acct_ok = False
+ issues.append(f"{wl_id} seed {r['seed']} queries={r['queries']} samples={r['sample_evaluations']}")
+ gate_results["query_and_sample_accounting_exact"] = acct_ok
+
+ # 7. PSO validation NLL <= uniform ensemble NLL + 1e-7
+ pso_nll_vs_uniform_ok = True
+ for wl_id, wl in workloads_data.items():
+ pso_nll = wl["validation"]["methods"]["pso_weights"]["metrics"]["nll"]
+ uni_nll = wl["validation"]["methods"]["uniform_ensemble"]["nll"]
+ if pso_nll > uni_nll + 1e-7:
+ pso_nll_vs_uniform_ok = False
+ issues.append(f"{wl_id} PSO val NLL {pso_nll:.6f} > uniform {uni_nll:.6f}")
+ gate_results["maximum_pso_nll_regression_vs_uniform"] = pso_nll_vs_uniform_ok
+
+ # 8. PSO validation accuracy regression vs uniform <= 0.10 pp
+ pso_acc_vs_uniform_ok = True
+ for wl_id, wl in workloads_data.items():
+ pso_acc = wl["validation"]["methods"]["pso_weights"]["metrics"]["accuracy"]
+ uni_acc = wl["validation"]["methods"]["uniform_ensemble"]["accuracy"]
+ if uni_acc - pso_acc > 0.10:
+ pso_acc_vs_uniform_ok = False
+ issues.append(f"{wl_id} PSO val acc {pso_acc:.4f}% regressed >0.10pp vs uniform {uni_acc:.4f}%")
+ gate_results["maximum_pso_accuracy_regression_vs_uniform_pp"] = pso_acc_vs_uniform_ok
+
+ # 9. PSO validation NLL < reference single 10e NLL
+ pso_nll_vs_ref_ok = True
+ for wl_id, wl in workloads_data.items():
+ pso_nll = wl["validation"]["methods"]["pso_weights"]["metrics"]["nll"]
+ ref_nll = wl["validation"]["methods"]["reference_single_10e"]["nll"]
+ if pso_nll >= ref_nll:
+ pso_nll_vs_ref_ok = False
+ issues.append(f"{wl_id} PSO val NLL {pso_nll:.6f} >= ref single {ref_nll:.6f}")
+ gate_results["pso_nll_below_reference_single"] = pso_nll_vs_ref_ok
+
+ # 10. PSO validation NLL <= single_50e NLL + 1e-7
+ pso_nll_vs_50e_ok = True
+ for wl_id, wl in workloads_data.items():
+ pso_nll = wl["validation"]["methods"]["pso_weights"]["metrics"]["nll"]
+ s50_nll = wl["validation"]["methods"]["single_50e"]["nll"]
+ if pso_nll > s50_nll + 1e-7:
+ pso_nll_vs_50e_ok = False
+ issues.append(f"{wl_id} PSO val NLL {pso_nll:.6f} > single_50e {s50_nll:.6f}")
+ gate_results["maximum_pso_nll_regression_vs_equal_budget_single"] = pso_nll_vs_50e_ok
+
+ # 11. PSO validation NLL within 0.5% of SLSQP validation NLL
+ pso_gap_slsqp_ok = True
+ for wl_id, wl in workloads_data.items():
+ pso_nll = wl["validation"]["methods"]["pso_weights"]["metrics"]["nll"]
+ slsqp_nll = wl["validation"]["methods"]["slsqp_weights"]["metrics"]["nll"]
+ rel_gap = (pso_nll - slsqp_nll) / slsqp_nll
+ if rel_gap > 0.005:
+ pso_gap_slsqp_ok = False
+ issues.append(f"{wl_id} PSO vs SLSQP relative NLL gap {rel_gap:.4f} > 0.005")
+ gate_results["maximum_relative_pso_nll_gap_vs_slsqp"] = pso_gap_slsqp_ok
+
+ # 12. Cross-dataset mean relative PSO NLL reduction vs uniform >= 0.0
+ rel_reductions = []
+ for wl_id, wl in workloads_data.items():
+ pso_nll = wl["validation"]["methods"]["pso_weights"]["metrics"]["nll"]
+ uni_nll = wl["validation"]["methods"]["uniform_ensemble"]["nll"]
+ rel_red = (uni_nll - pso_nll) / uni_nll
+ rel_reductions.append(rel_red)
+ mean_rel_red = float(np.mean(rel_reductions)) if rel_reductions else -1.0
+ mean_rel_red_ok = mean_rel_red >= 0.0
+ if not mean_rel_red_ok:
+ issues.append(f"Mean relative NLL reduction vs uniform {mean_rel_red:.6f} < 0.0")
+ gate_results["cross_dataset_mean_relative_pso_nll_reduction_vs_uniform_minimum"] = mean_rel_red_ok
+
+ # 13. Median 1-seed PSO wall time / pool training wall time <= 0.10
+ wall_ratio_ok = True
+ for wl_id, wl in workloads_data.items():
+ med_pso_wall = wl["validation"]["methods"]["pso_weights"]["median_one_seed_wall_time_seconds"]
+ pool_wall = wl["training"]["adam_pool_wall_time_seconds"]
+ ratio = med_pso_wall / pool_wall if pool_wall > 0 else 1.0
+ if ratio > 0.10:
+ wall_ratio_ok = False
+ issues.append(f"{wl_id} PSO median wall time ratio {ratio:.4f} > 0.10")
+ gate_results["maximum_median_one_seed_pso_to_pool_training_wall_ratio"] = wall_ratio_ok
+
+ all_pass = all(gate_results.values())
+ failed_count = sum(1 for v in gate_results.values() if not v)
+
+ return {
+ "pass": all_pass,
+ "failed_hard_gate_count": failed_count,
+ "gate_results": gate_results,
+ "issues": issues,
+ }
+
+
+# =====================================================================
+# 8. Publication Output Writers (Atomic Write via os.replace)
+# =====================================================================
+
+def atomic_write_file(target_path: Path, content_str_or_bytes: Union[str, bytes], is_binary: bool = False):
+ target_path = Path(target_path)
+ target_path.parent.mkdir(parents=True, exist_ok=True)
+ fd, tmp_path = tempfile.mkstemp(dir=str(target_path.parent), prefix=f".tmp_{target_path.name}_")
+ try:
+ with os.fdopen(fd, 'wb' if is_binary else 'w', encoding=None if is_binary else 'utf-8') as f:
+ f.write(content_str_or_bytes)
+ os.replace(tmp_path, target_path)
+ except Exception:
+ if os.path.exists(tmp_path):
+ os.remove(tmp_path)
+ raise
+
+
+def save_csv_report(artifact: Dict[str, Any], output_path: Path):
+ lines = [
+ "Workload,Phase,Method,Accuracy,NLL,Brier,ECE,Margin,WallTimeSeconds,ParameterMultiplier,InferenceMultiplier"
+ ]
+
+ method_multipliers = {
+ "reference_single_10e": (1.0, 1.0),
+ "best_single_10e": (1.0, 1.0),
+ "single_50e": (1.0, 1.0),
+ "uniform_ensemble": (5.0, 5.0),
+ "uniform_temperature": (5.0, 5.0),
+ "slsqp_weights": (5.0, 5.0),
+ "pso_weights": (5.0, 5.0),
+ }
+
+ for wl_id, wl in artifact["workloads"].items():
+ # Validation Phase
+ val_methods = wl["validation"]["methods"]
+ for m_name, m_data in val_methods.items():
+ if m_name == "pso_weights":
+ mets = m_data["metrics"]
+ wall_t = m_data["median_one_seed_wall_time_seconds"]
+ elif m_name == "slsqp_weights":
+ mets = m_data["metrics"]
+ wall_t = m_data["wall_time_seconds"]
+ elif m_name == "uniform_temperature":
+ mets = m_data["metrics"]
+ wall_t = m_data.get("wall_time_seconds", 0.0)
+ else:
+ mets = m_data
+ wall_t = 0.0
+
+ param_m, inf_m = method_multipliers.get(m_name, (1.0, 1.0))
+ line = f"{wl_id},validation,{m_name},{mets['accuracy']:.4f},{mets['nll']:.6f},{mets['brier']:.6f},{mets['ece']:.6f},{mets['margin']:.6f},{wall_t:.4f},{param_m:.1f},{inf_m:.1f}"
+ lines.append(line)
+
+ # Confirmation / Test Phase
+ if wl.get("confirmation") is not None:
+ test_methods = wl["confirmation"]["methods"]
+ for m_name, mets in test_methods.items():
+ param_m, inf_m = method_multipliers.get(m_name, (1.0, 1.0))
+ line = f"{wl_id},official_test,{m_name},{mets['accuracy']:.4f},{mets['nll']:.6f},{mets['brier']:.6f},{mets['ece']:.6f},{mets['margin']:.6f},0.0000,{param_m:.1f},{inf_m:.1f}"
+ lines.append(line)
+
+ csv_content = "\n".join(lines) + "\n"
+ atomic_write_file(output_path, csv_content, is_binary=False)
+
+
+def save_publication_plot(artifact: Dict[str, Any], output_path: Path):
+ """Write the validation/test summary figure without assuming confirmation ran.
+
+ The development artifact is the primary source for this figure. Official-test
+ panels are intentionally left empty when development gates fail, rather than
+ silently reusing validation values or omitting methods from the comparison.
+ """
+ methods_order = [
+ "reference_single_10e",
+ "best_single_10e",
+ "single_50e",
+ "uniform_ensemble",
+ "uniform_temperature",
+ "slsqp_weights",
+ "pso_weights",
+ ]
+ method_labels = [
+ "Ref 10e",
+ "Best 10e",
+ "Single 50e",
+ "Uniform",
+ "Temp uniform",
+ "SLSQP",
+ "PSO",
+ ]
+
+ workloads_data = artifact.get("workloads", {})
+ workloads = list(workloads_data.keys())
+
+ def _method_record(wl: Dict[str, Any], phase: str, method: str) -> Dict[str, Any]:
+ phase_record = wl.get(phase)
+ if not isinstance(phase_record, dict):
+ return {}
+ methods = phase_record.get("methods")
+ if not isinstance(methods, dict):
+ return {}
+ record = methods.get(method)
+ return record if isinstance(record, dict) else {}
+
+ def _metrics(wl: Dict[str, Any], phase: str, method: str) -> Dict[str, Any]:
+ record = _method_record(wl, phase, method)
+ nested = record.get("metrics")
+ return nested if isinstance(nested, dict) else record
+
+ def _number(value: Any) -> float:
+ try:
+ value = float(value)
+ except (TypeError, ValueError):
+ return float("nan")
+ return value if math.isfinite(value) else float("nan")
+
+ def _count_text(value: Any) -> str:
+ """Format optional sample counts without assuming a complete artifact."""
+ try:
+ return f"{int(value):,}"
+ except (TypeError, ValueError):
+ return "—"
+
+ def _metric(wl: Dict[str, Any], phase: str, method: str, name: str) -> float:
+ return _number(_metrics(wl, phase, method).get(name))
+
+ def _grouped_metric(
+ ax: Any,
+ phase: str,
+ metric_name: str,
+ title: str,
+ ylabel: str,
+ unavailable_text: Optional[str] = None,
+ ) -> bool:
+ """Draw one phase/metric panel and return whether any value was present."""
+ x = np.arange(len(methods_order), dtype=float)
+ n_workloads = max(len(workloads), 1)
+ width = min(0.8 / n_workloads, 0.28)
+ plotted = False
+ observed: List[float] = []
+ cmap = plt.get_cmap("tab10")
+
+ for workload_idx, wl_id in enumerate(workloads):
+ wl = workloads_data[wl_id]
+ values = [
+ _metric(wl, phase, method, metric_name)
+ for method in methods_order
+ ]
+ observed.extend(value for value in values if math.isfinite(value))
+ if any(math.isfinite(value) for value in values):
+ plotted = True
+ offset = (workload_idx - (n_workloads - 1) / 2.0) * width
+ ax.bar(
+ x + offset,
+ values,
+ width=width,
+ label=wl_id.replace("_", " ").title(),
+ color=cmap(workload_idx % 10),
+ alpha=0.88,
+ edgecolor="white",
+ linewidth=0.4,
+ )
+
+ display_title = title
+ if plotted and metric_name == "nll":
+ positive_values = [value for value in observed if value > 0]
+ if len(positive_values) == len(observed):
+ ax.set_yscale("log")
+ display_title = f"{title} (log scale)"
+ elif plotted and metric_name == "accuracy":
+ # Accuracy differences are sub-percentage-point on the official
+ # test set; a zero-based axis makes the methods indistinguishable.
+ low = max(0.0, min(observed) - 1.0)
+ high = min(100.0, max(observed) + 0.5)
+ if high <= low:
+ high = min(100.0, low + 1.0)
+ ax.set_ylim(low, high)
+
+ ax.set_title(display_title)
+ ax.set_ylabel(ylabel)
+ ax.set_xticks(x)
+ ax.set_xticklabels(method_labels, rotation=32, ha="right", fontsize=8)
+ ax.grid(True, axis="y", linestyle="--", alpha=0.35)
+ ax.set_axisbelow(True)
+ if not plotted and unavailable_text:
+ ax.text(
+ 0.5,
+ 0.52,
+ unavailable_text,
+ transform=ax.transAxes,
+ ha="center",
+ va="center",
+ fontsize=10,
+ color="#555555",
+ wrap=True,
+ )
+ return plotted
+
+ fig, axes = plt.subplots(2, 3, figsize=(18, 10), squeeze=False)
+ fig.suptitle(
+ "Post-Training Prediction-Space Ensemble Study",
+ fontsize=16,
+ fontweight="bold",
+ )
+
+ # The first four panels keep validation context beside the sealed,
+ # one-shot official-test confirmation results.
+ _grouped_metric(
+ axes[0, 0],
+ "validation",
+ "nll",
+ "Validation NLL (lower is better)",
+ "NLL",
+ )
+ has_test_nll = _grouped_metric(
+ axes[0, 1],
+ "confirmation",
+ "nll",
+ "Official-test NLL (lower is better)",
+ "NLL",
+ "Official test not run:\ndevelopment gates failed",
+ )
+ _grouped_metric(
+ axes[1, 0],
+ "validation",
+ "accuracy",
+ "Validation accuracy (higher is better)",
+ "Accuracy (%)",
+ )
+ has_test_accuracy = _grouped_metric(
+ axes[1, 1],
+ "confirmation",
+ "accuracy",
+ "Official-test accuracy (higher is better)",
+ "Accuracy (%)",
+ "Official test not run:\ndevelopment gates failed",
+ )
+
+ # Efficiency is shown separately from accuracy/NLL so the plot does not
+ # imply that a slower optimizer is a better ensemble method.
+ ax_eff = axes[0, 2]
+ efficiency_categories = [
+ "Pool\n5x10e",
+ "Single\n50e",
+ "Temp\nuniform",
+ "SLSQP",
+ "PSO\n1 seed",
+ "PSO\n3 seeds",
+ ]
+ n_workloads = max(len(workloads), 1)
+ x_eff = np.arange(len(efficiency_categories), dtype=float)
+ width_eff = min(0.8 / n_workloads, 0.28)
+ efficiency_plotted = False
+ cmap = plt.get_cmap("tab10")
+ for workload_idx, wl_id in enumerate(workloads):
+ wl = workloads_data[wl_id]
+ training = wl.get("training", {})
+ val_methods = wl.get("validation", {}).get("methods", {})
+ temp_rec = val_methods.get("uniform_temperature", {})
+ slsqp_rec = val_methods.get("slsqp_weights", {})
+ pso_rec = val_methods.get("pso_weights", {})
+ values = [
+ _number(training.get("adam_pool_wall_time_seconds")),
+ _number(training.get("single_50e_wall_time_seconds")),
+ _number(temp_rec.get("wall_time_seconds")),
+ _number(slsqp_rec.get("wall_time_seconds")),
+ _number(pso_rec.get("median_one_seed_wall_time_seconds")),
+ _number(pso_rec.get("total_wall_time_seconds")),
+ ]
+ if any(math.isfinite(value) and value > 0 for value in values):
+ efficiency_plotted = True
+ offset = (workload_idx - (n_workloads - 1) / 2.0) * width_eff
+ ax_eff.bar(
+ x_eff + offset,
+ values,
+ width=width_eff,
+ label=wl_id.replace("_", " ").title(),
+ color=cmap(workload_idx % 10),
+ alpha=0.88,
+ edgecolor="white",
+ linewidth=0.4,
+ )
+ ax_eff.set_title(
+ "Efficiency: wall time (log scale)" if efficiency_plotted
+ else "Efficiency: wall time"
+ )
+ ax_eff.set_ylabel("Seconds")
+ ax_eff.set_xticks(x_eff)
+ ax_eff.set_xticklabels(efficiency_categories, fontsize=8)
+ if efficiency_plotted:
+ ax_eff.set_yscale("log")
+ ax_eff.grid(True, axis="y", linestyle="--", alpha=0.35)
+ ax_eff.set_axisbelow(True)
+ if not efficiency_plotted:
+ ax_eff.text(
+ 0.5,
+ 0.52,
+ "Efficiency data unavailable",
+ transform=ax_eff.transAxes,
+ ha="center",
+ va="center",
+ fontsize=10,
+ color="#555555",
+ )
+
+ # Context panel makes the data freeze and a development-only artifact
+ # explicit in the publication figure.
+ ax_context = axes[1, 2]
+ ax_context.axis("off")
+ config = artifact.get("config", {})
+ resource_totals = artifact.get("resource_totals", {})
+ dev_pass = artifact.get("development_pass")
+ test_loaded = artifact.get("official_test_data_loaded")
+ confirmation_available = has_test_nll or has_test_accuracy
+ status = "PASS" if dev_pass is True else "FAIL / not confirmed"
+ test_status = "available" if confirmation_available else "not run"
+ pool_seeds = config.get("pool_seeds", [])
+ lines = [
+ "Study context",
+ f"Workloads: {', '.join(w.replace('_', ' ').title() for w in workloads) or 'none'}",
+ f"Validation: {_count_text(config.get('search_samples'))} search / "
+ f"{_count_text(config.get('validation_samples'))} holdout",
+ f"Pool: {len(pool_seeds) or 5} independently trained models",
+ f"Development gates: {status}",
+ f"Official test data: {'loaded' if test_loaded else 'sealed'}",
+ f"Official confirmation: {test_status}",
+ "",
+ "Prediction-space weights; no model soup",
+ ]
+ pso_research = resource_totals.get(
+ "pso_research_wall_time_seconds",
+ resource_totals.get("total_pso_wall_time_seconds"),
+ )
+ pso_ratio = resource_totals.get("pso_to_pool_wall_ratio")
+ slsqp_total = resource_totals.get("slsqp_total_wall_time_seconds")
+ if pso_research is not None or slsqp_total is not None:
+ lines.extend(
+ [
+ "",
+ f"PSO research time: {_number(pso_research):.3f}s",
+ f"SLSQP total time: {_number(slsqp_total):.3f}s",
+ ]
+ )
+ if pso_ratio is not None:
+ lines.append(f"Median workload PSO / pool ratio: {_number(pso_ratio):.2%}")
+ ax_context.text(
+ 0.03,
+ 0.97,
+ "\n".join(lines),
+ transform=ax_context.transAxes,
+ va="top",
+ ha="left",
+ fontsize=10,
+ linespacing=1.45,
+ family="DejaVu Sans",
+ )
+ if not confirmation_available:
+ ax_context.text(
+ 0.03,
+ 0.08,
+ "Validation results are retained; official-test panels are\n"
+ "intentionally unavailable because the policy was not confirmed.",
+ transform=ax_context.transAxes,
+ va="bottom",
+ ha="left",
+ fontsize=9,
+ color="#8a3b12",
+ wrap=True,
+ )
+ # One shared workload legend keeps the data panels uncluttered while
+ # preserving the dataset color mapping across all comparisons.
+ if workloads:
+ legend_handles, legend_labels = axes[0, 0].get_legend_handles_labels()
+ if legend_handles:
+ fig.legend(
+ legend_handles,
+ legend_labels,
+ loc="upper center",
+ bbox_to_anchor=(0.5, 0.925),
+ ncol=min(4, len(legend_labels)),
+ frameon=False,
+ fontsize=9,
+ title="Dataset",
+ )
+
+ fig.tight_layout(rect=(0, 0, 1, 0.88))
+
+
+ buf = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
+ buf_path = Path(buf.name)
+ buf.close()
+ try:
+ fig.savefig(buf_path, format="png", dpi=180, bbox_inches="tight")
+ with open(buf_path, "rb") as f:
+ img_bytes = f.read()
+ # Keep publication output atomic even when plotting or serialization
+ # fails partway through.
+ atomic_write_file(output_path, img_bytes, is_binary=True)
+ finally:
+ plt.close(fig)
+ if buf_path.exists():
+ buf_path.unlink()
+
+# =====================================================================
+# 9. Main Orchestration Function
+# =====================================================================
+
+def run_post_training_study(
+ cache_dir: Optional[Union[str, Path]] = None,
+ device: Optional[str] = None,
+ output_json: Optional[Union[str, Path]] = None,
+ output_csv: Optional[Union[str, Path]] = None,
+ output_png: Optional[Union[str, Path]] = None,
+) -> Dict[str, Any]:
+ if cache_dir is None:
+ cache_dir = Path("result/cache")
+ else:
+ cache_dir = Path(cache_dir)
+
+ if output_json is None:
+ output_json = Path("benchmark_results/pso_v8_post_training_ensemble.json")
+ else:
+ output_json = Path(output_json)
+
+ if output_csv is None:
+ output_csv = Path("benchmark_results/pso_v8_post_training_ensemble.csv")
+ else:
+ output_csv = Path(output_csv)
+
+ if output_png is None:
+ output_png = Path("history_plt/pso_v8_post_training_ensemble.png")
+ else:
+ output_png = Path(output_png)
+
+ dev = resolve_device(device)
+ print(f"[{PROTOCOL_VERSION}] Starting study on device={dev}...")
+
+ pool_seeds = [201, 202, 203, 204, 205]
+ swarm_seeds = [301, 302, 303]
+ dataset_names = ["mnist", "fashion_mnist"]
+
+ workloads: Dict[str, Any] = {}
+ retained_trained_models: Dict[str, Dict[str, Any]] = {}
+
+ for ds_name in dataset_names:
+ print(f"\n--- Workload: {ds_name} ---")
+ x_search, y_search, x_val, y_val, provenance = prepare_dataset_splits(
+ dataset_name=ds_name,
+ split_seed=20260904,
+ cache_dir=cache_dir,
+ )
+
+ # -------------------------------------------------------------
+ # Step A: Train Pool & 50e Single Model
+ # -------------------------------------------------------------
+ pool_models: Dict[int, nn.Module] = {}
+ pool_train_times: List[float] = []
+ model_fingerprints: Dict[str, str] = {}
+
+ # 1) Seed 201: Train for 10 epochs (capture reference single), then continue to 50 epochs (single_50e)
+ torch.manual_seed(201)
+ model_201 = CompactCNN().to(dev)
+ opt_201 = torch.optim.Adam(model_201.parameters(), lr=0.001)
+ criterion = nn.CrossEntropyLoss()
+
+ g_201 = torch.Generator()
+ g_201.manual_seed(201)
+ search_ds = TensorDataset(x_search, y_search)
+ loader_201 = DataLoader(search_ds, batch_size=256, shuffle=True, generator=g_201)
+
+ sync_device(dev)
+ t_start_201 = time.perf_counter()
+ model_201.train()
+ for epoch in range(1, 11):
+ for bx, by in loader_201:
+ bx, by = bx.to(dev), by.to(dev)
+ opt_201.zero_grad()
+ out = model_201(bx)
+ loss = criterion(out, by)
+ loss.backward()
+ opt_201.step()
+ sync_device(dev)
+ t_10e_201 = time.perf_counter() - t_start_201
+ pool_train_times.append(t_10e_201)
+
+ # Save 10e model snapshot for pool seed 201
+ m_201_10e = CompactCNN().to(dev)
+ m_201_10e.load_state_dict(copy.deepcopy(model_201.state_dict()))
+ pool_models[201] = m_201_10e
+ model_fingerprints["201"] = compute_model_fingerprint(m_201_10e)
+
+ # Continue exact same model_201 and optimizer stream to epoch 50
+ for epoch in range(11, 51):
+ for bx, by in loader_201:
+ bx, by = bx.to(dev), by.to(dev)
+ opt_201.zero_grad()
+ out = model_201(bx)
+ loss = criterion(out, by)
+ loss.backward()
+ opt_201.step()
+ sync_device(dev)
+ t_50e_201 = time.perf_counter() - t_start_201
+ single_50e_model = model_201
+ model_fingerprints["single_50e"] = compute_model_fingerprint(single_50e_model)
+
+ # 2) Seeds 202-205: Train 10 epochs each
+ for seed in [202, 203, 204, 205]:
+ torch.manual_seed(seed)
+ m = CompactCNN().to(dev)
+ opt_m = torch.optim.Adam(m.parameters(), lr=0.001)
+ g_m = torch.Generator()
+ g_m.manual_seed(seed)
+ loader_m = DataLoader(search_ds, batch_size=256, shuffle=True, generator=g_m)
+
+ sync_device(dev)
+ t_start_m = time.perf_counter()
+ m.train()
+ for epoch in range(1, 11):
+ for bx, by in loader_m:
+ bx, by = bx.to(dev), by.to(dev)
+ opt_m.zero_grad()
+ out = m(bx)
+ loss = criterion(out, by)
+ loss.backward()
+ opt_m.step()
+ sync_device(dev)
+ t_m = time.perf_counter() - t_start_m
+ pool_train_times.append(t_m)
+ pool_models[seed] = m
+ model_fingerprints[str(seed)] = compute_model_fingerprint(m)
+
+ pool_training_wall_t = float(sum(pool_train_times))
+
+ training_rec = {
+ "architecture": "CompactCNN",
+ "parameters": 9098,
+ "pool_seeds": pool_seeds,
+ "pool_epochs_each": 10,
+ "adam_pool_epochs": 50,
+ "adam_lr": 0.001,
+ "adam_batch_size": 256,
+ "adam_pool_wall_time_seconds": pool_training_wall_t,
+ "single_50e_epochs": 50,
+ "single_50e_wall_time_seconds": float(t_50e_201),
+ "model_fingerprints": model_fingerprints,
+ }
+
+ # Retain trained models in memory for exact official test evaluation without retraining
+ retained_trained_models[ds_name] = {
+ "pool_models": pool_models,
+ "single_50e_model": single_50e_model,
+ }
+
+ # -------------------------------------------------------------
+ # Step B: Create Validation Probability Cache
+ # -------------------------------------------------------------
+ sync_device(dev)
+ t0_val_cache = time.perf_counter()
+ val_probs_list = []
+ for seed in pool_seeds:
+ p_m, _ = get_model_probabilities(pool_models[seed], x_val, dev)
+ val_probs_list.append(p_m)
+
+ val_pool_probs_t = torch.stack(val_probs_list, dim=0) # (5, 10000, 10)
+ cache_valid = validate_probability_cache(val_pool_probs_t)
+
+ val_50e_probs_t, _ = get_model_probabilities(single_50e_model, x_val, dev)
+ sync_device(dev)
+ val_cache_wall_t = time.perf_counter() - t0_val_cache
+
+ val_pool_bytes = int(val_pool_probs_t.element_size() * val_pool_probs_t.nelement()) + int(val_50e_probs_t.element_size() * val_50e_probs_t.nelement())
+
+ validation_cache_rec = {
+ "valid": cache_valid,
+ "pool_forward_passes": 5,
+ "long_single_forward_passes": 1,
+ "base_cnn_forward_passes_during_optimization": 0,
+ "shape": list(val_pool_probs_t.shape),
+ "memory_bytes": val_pool_bytes,
+ "wall_time_seconds": float(val_cache_wall_t),
+ }
+
+ # -------------------------------------------------------------
+ # Step C: Evaluate Validation Baselines & Optimization Methods
+ # -------------------------------------------------------------
+ val_pool_probs_np = val_pool_probs_t.numpy()
+ val_50e_probs_np = val_50e_probs_t.numpy()
+ y_val_np = y_val.numpy()
+
+ # 1) reference_single_10e (seed 201)
+ ref_single_metrics = probabilistic_metrics(val_pool_probs_np[0], y_val_np)
+
+ # 2) best_single_10e
+ pool_nlls = [probabilistic_metrics(val_pool_probs_np[i], y_val_np)["nll"] for i in range(5)]
+ best_single_idx = int(np.argmin(pool_nlls))
+ best_single_seed = pool_seeds[best_single_idx]
+ best_single_metrics = probabilistic_metrics(val_pool_probs_np[best_single_idx], y_val_np)
+ best_single_metrics["selected_seed"] = best_single_seed
+
+ # 3) single_50e
+ s50e_metrics = probabilistic_metrics(val_50e_probs_np, y_val_np)
+
+ # 4) uniform_ensemble
+ uniform_probs = val_pool_probs_np.mean(axis=0)
+ uniform_metrics = probabilistic_metrics(uniform_probs, y_val_np)
+
+ # 5) uniform_temperature
+ fitted_temp, uniform_temp_rec = fit_uniform_temperature(uniform_probs, y_val_np)
+
+ # 6) slsqp_weights
+ slsqp_rec = optimize_slsqp_weights(val_pool_probs_np, y_val_np)
+
+ # 7) pso_weights (Iteration 1: 30 particles x 30 epochs = 900 queries per seed)
+ pso_rec = run_pso_weights(val_pool_probs_t, y_val, swarm_seeds=swarm_seeds, particles=30, epochs=30, device=str(dev))
+
+ validation_rec = {
+ "methods": {
+ "reference_single_10e": ref_single_metrics,
+ "best_single_10e": best_single_metrics,
+ "single_50e": s50e_metrics,
+ "uniform_ensemble": uniform_metrics,
+ "uniform_temperature": uniform_temp_rec,
+ "slsqp_weights": slsqp_rec,
+ "pso_weights": pso_rec,
+ }
+ }
+
+ workloads[ds_name] = {
+ "provenance": provenance,
+ "training": training_rec,
+ "validation_cache": validation_cache_rec,
+ "validation": validation_rec,
+ "official_test_data_loaded_before_freeze": False,
+ "official_test_evaluations_before_freeze": 0,
+ "confirmation": None,
+ }
+
+ # -----------------------------------------------------------------
+ # Step D: Development Gates Evaluation & Policy Freeze
+ # -----------------------------------------------------------------
+ dev_gate_res = evaluate_development_gates(workloads)
+ dev_pass = dev_gate_res["pass"]
+
+ print(f"\n=== Development Phase Summary ===")
+ print(f"Development Pass: {dev_pass} (Failed Gates: {dev_gate_res['failed_hard_gate_count']})")
+ for g_name, g_status in dev_gate_res["gate_results"].items():
+ print(f" - {g_name}: {'PASS' if g_status else 'FAIL'}")
+ if dev_gate_res["issues"]:
+ print("Issues:")
+ for iss in dev_gate_res["issues"]:
+ print(f" * {iss}")
+
+ policy_frozen = True
+ official_test_data_loaded = False
+
+ # -----------------------------------------------------------------
+ # Step E: Deferred Official Test Loading & Evaluation (If Dev Passed)
+ # Reuses retained models directly; NEVER retrains after freeze.
+ # -----------------------------------------------------------------
+ if dev_pass:
+ print("\n=== Official Test Confirmation Phase ===")
+ official_test_data_loaded = True
+
+ for ds_name in dataset_names:
+ wl = workloads[ds_name]
+ mean_v = wl["provenance"]["normalization"]["mean"]
+ std_v = wl["provenance"]["normalization"]["std"]
+
+ x_test, y_test = load_official_test_data(
+ dataset_name=ds_name,
+ mean_val=mean_v,
+ std_val=std_v,
+ cache_dir=cache_dir,
+ )
+
+ # Reuse retained trained models directly (NO RETRAINING)
+ ret_pool = retained_trained_models[ds_name]["pool_models"]
+ ret_50e = retained_trained_models[ds_name]["single_50e_model"]
+
+ sync_device(dev)
+ t0_test_cache = time.perf_counter()
+ test_pool_probs_list = []
+ for seed in pool_seeds:
+ p_m, _ = get_model_probabilities(ret_pool[seed], x_test, dev)
+ test_pool_probs_list.append(p_m)
+
+ p_test_50e, _ = get_model_probabilities(ret_50e, x_test, dev)
+ sync_device(dev)
+ test_cache_wall_t = time.perf_counter() - t0_test_cache
+
+ test_pool_probs_t = torch.stack(test_pool_probs_list, dim=0) # (5, 10000, 10)
+ test_bytes = int(test_pool_probs_t.element_size() * test_pool_probs_t.nelement()) + int(p_test_50e.element_size() * p_test_50e.nelement())
+
+ test_pool_probs_np = test_pool_probs_t.numpy()
+ test_50e_probs_np = p_test_50e.numpy()
+ y_test_np = y_test.numpy()
+
+ # Retrieve frozen parameters from validation phase
+ frozen_pso_w = wl["validation"]["methods"]["pso_weights"]["selected_weights"]
+ frozen_pso_seed = wl["validation"]["methods"]["pso_weights"]["selected_seed"]
+ frozen_slsqp_w = wl["validation"]["methods"]["slsqp_weights"]["weights"]
+ frozen_temp = wl["validation"]["methods"]["uniform_temperature"]["fitted_temperature"]
+ val_best_seed_idx = pool_seeds.index(wl["validation"]["methods"]["best_single_10e"]["selected_seed"])
+
+ # Evaluate frozen methods on official test cache
+ test_ref_single = probabilistic_metrics(test_pool_probs_np[0], y_test_np)
+ test_best_single = probabilistic_metrics(test_pool_probs_np[val_best_seed_idx], y_test_np)
+ test_single_50e = probabilistic_metrics(test_50e_probs_np, y_test_np)
+
+ test_uniform_probs = test_pool_probs_np.mean(axis=0)
+ test_uniform_ensemble = probabilistic_metrics(test_uniform_probs, y_test_np)
+
+ test_temp_probs = temp_scaled_probs(test_uniform_probs, frozen_temp)
+ test_uniform_temp = probabilistic_metrics(test_temp_probs, y_test_np)
+
+ test_slsqp_mix = mixture_probabilities(frozen_slsqp_w, test_pool_probs_np)
+ test_slsqp = probabilistic_metrics(test_slsqp_mix, y_test_np)
+
+ test_pso_mix = mixture_probabilities(frozen_pso_w, test_pool_probs_np)
+ test_pso = probabilistic_metrics(test_pso_mix, y_test_np)
+
+ # Confirmation Gates
+ c_finite = all(
+ math.isfinite(v)
+ for m_dict in [test_ref_single, test_best_single, test_single_50e, test_uniform_ensemble, test_uniform_temp, test_slsqp, test_pso]
+ for v in m_dict.values()
+ )
+ c_acc_reg = (test_uniform_ensemble["accuracy"] - test_pso["accuracy"]) <= 0.20
+ c_nll_ref = test_pso["nll"] < test_ref_single["nll"]
+ c_nll_50e = test_pso["nll"] <= test_single_50e["nll"] + 1e-7
+ c_pass = c_finite and c_acc_reg and c_nll_ref and c_nll_50e
+
+ confirmation_rec = {
+ "official_test_data_loaded": True,
+ "test_cache_counts": {
+ "dataset_loads": 1,
+ "pool_forward_passes": 5,
+ "long_single_forward_passes": 1,
+ "base_cnn_forward_passes_during_optimization": 0,
+ "memory_bytes": test_bytes,
+ "wall_time_seconds": float(test_cache_wall_t),
+ },
+ "frozen_methods": {
+ "selected_pso_seed": frozen_pso_seed,
+ "selected_pso_weights": frozen_pso_w,
+ "slsqp_weights": frozen_slsqp_w,
+ "fitted_temperature": frozen_temp,
+ },
+ "methods": {
+ "reference_single_10e": test_ref_single,
+ "best_single_10e": test_best_single,
+ "single_50e": test_single_50e,
+ "uniform_ensemble": test_uniform_ensemble,
+ "uniform_temperature": test_uniform_temp,
+ "slsqp_weights": test_slsqp,
+ "pso_weights": test_pso,
+ },
+ "confirmation_gates": {
+ "all_values_finite": c_finite,
+ "official_test_dataset_loads": 1,
+ "official_test_pool_forward_passes": 5,
+ "official_test_long_single_forward_passes": 1,
+ "maximum_pso_accuracy_regression_vs_uniform_pp": c_acc_reg,
+ "pso_nll_below_reference_single": c_nll_ref,
+ "maximum_pso_nll_regression_vs_equal_budget_single": c_nll_50e,
+ "pass": c_pass,
+ }
+ }
+ wl["confirmation"] = confirmation_rec
+
+ # -----------------------------------------------------------------
+ # Step F: Assemble Global Artifact & Resource Totals
+ # -----------------------------------------------------------------
+ adam_pool_epochs = sum(wl["training"]["adam_pool_epochs"] for wl in workloads.values())
+ adam_pool_wall_t = float(sum(wl["training"]["adam_pool_wall_time_seconds"] for wl in workloads.values()))
+ single_50e_wall_t = float(sum(wl["training"]["single_50e_wall_time_seconds"] for wl in workloads.values()))
+
+ val_fwd_passes = sum(
+ wl["validation_cache"]["pool_forward_passes"] + wl["validation_cache"]["long_single_forward_passes"]
+ for wl in workloads.values()
+ )
+
+ pso_tot_queries = sum(wl["validation"]["methods"]["pso_weights"]["total_queries"] for wl in workloads.values())
+ pso_tot_samples = sum(wl["validation"]["methods"]["pso_weights"]["total_sample_evaluations"] for wl in workloads.values())
+ pso_res_wall_t = float(sum(wl["validation"]["methods"]["pso_weights"]["total_wall_time_seconds"] for wl in workloads.values()))
+ pso_prod_wall_t = float(sum(
+ next(r["wall_time_seconds"] for r in wl["validation"]["methods"]["pso_weights"]["per_seed_runs"]
+ if r["seed"] == wl["validation"]["methods"]["pso_weights"]["selected_seed"])
+ for wl in workloads.values()
+ ))
+
+ slsqp_tot_evals = sum(wl["validation"]["methods"]["slsqp_weights"]["evaluations"] for wl in workloads.values())
+ slsqp_tot_wall_t = float(sum(wl["validation"]["methods"]["slsqp_weights"]["wall_time_seconds"] for wl in workloads.values()))
+
+ test_fwd_passes = sum(
+ wl["confirmation"]["test_cache_counts"]["pool_forward_passes"] + wl["confirmation"]["test_cache_counts"]["long_single_forward_passes"]
+ if wl.get("confirmation") is not None else 0
+ for wl in workloads.values()
+ )
+
+ pso_to_pool_ratios = [
+ wl["validation"]["methods"]["pso_weights"]["median_one_seed_wall_time_seconds"] / wl["training"]["adam_pool_wall_time_seconds"]
+ for wl in workloads.values()
+ ]
+ pso_to_pool_wall_ratio = float(np.median(pso_to_pool_ratios)) if pso_to_pool_ratios else 0.0
+ pso_max_workload_wall_ratio = float(max(pso_to_pool_ratios)) if pso_to_pool_ratios else 0.0
+ pso_production_to_pool_wall_ratio = (
+ pso_prod_wall_t / adam_pool_wall_t if adam_pool_wall_t > 0 else 0.0
+ )
+
+ resource_totals = {
+ "adam_pool_epochs": adam_pool_epochs,
+ "adam_pool_wall_time_seconds": adam_pool_wall_t,
+ "single_50e_wall_time_seconds": single_50e_wall_t,
+ "validation_cache_forward_passes": val_fwd_passes,
+ "pso_total_queries": pso_tot_queries,
+ "pso_total_sample_evaluations": pso_tot_samples,
+ "pso_research_wall_time_seconds": pso_res_wall_t,
+ "pso_production_wall_time_seconds": pso_prod_wall_t,
+ "pso_to_pool_wall_ratio": pso_to_pool_wall_ratio,
+ "pso_max_workload_wall_ratio": pso_max_workload_wall_ratio,
+ "pso_production_to_pool_wall_ratio": pso_production_to_pool_wall_ratio,
+ "slsqp_total_evaluations": slsqp_tot_evals,
+ "slsqp_total_wall_time_seconds": slsqp_tot_wall_t,
+ "official_test_cache_forward_passes": test_fwd_passes,
+ }
+
+ artifact = {
+ "protocol_version": PROTOCOL_VERSION,
+ "config": {
+ "iteration": 1,
+ "archived_iteration0_reference": {
+ "epochs": 50,
+ "queries_per_seed": 1500,
+ "sample_evaluations_per_seed": 15000000,
+ "reason": "wall_time_ratio_gate_exceeded",
+ },
+ "datasets": dataset_names,
+ "split_seed": 20260904,
+ "search_samples": 50000,
+ "validation_samples": 10000,
+ "pool_seeds": pool_seeds,
+ "reference_single_seed": 201,
+ "equal_budget_single_epochs": 50,
+ "adam_lr": 0.001,
+ "adam_batch_size": 256,
+ "pso": {
+ "method": "constriction",
+ "evaluation": "full",
+ "renewal": "loss",
+ "particles": 30,
+ "epochs": 30,
+ "swarm_seeds": swarm_seeds,
+ "queries_per_seed": 900,
+ "sample_evaluations_per_seed": 9000000,
+ "particle_bounds": [-4.0, 4.0],
+ "boundary_strategy": "reflect",
+ "velocity_limit_ratio": 0.1,
+ "initial_position_noise": 0.0,
+ },
+ "device": str(dev),
+ },
+ "workloads": workloads,
+ "development_pass": dev_pass,
+ "development_gates": dev_gate_res,
+ "policy_frozen": policy_frozen,
+ "official_test_data_loaded": official_test_data_loaded,
+ "official_test_evaluations_before_freeze": 0,
+ "post_test_tuning_or_reruns": 0,
+ "resource_totals": resource_totals,
+ }
+
+ # Write output artifacts atomically using temporary files + os.replace
+ json_bytes = json.dumps(artifact, indent=2).encode("utf-8")
+ atomic_write_file(output_json, json_bytes, is_binary=True)
+ print(f"\nArtifact saved to: {output_json}")
+
+ save_csv_report(artifact, output_csv)
+ print(f"CSV report saved to: {output_csv}")
+
+ save_publication_plot(artifact, output_png)
+ print(f"PNG plot saved to: {output_png}")
+
+ return artifact
+
+
+def main():
+ parser = argparse.ArgumentParser(description="Post-Training PSO Ensemble Study Runner")
+ parser.add_argument("--device", type=str, default=None, help="Device to use (cpu, mps, cuda)")
+ parser.add_argument("--cache-dir", type=str, default="result/cache", help="Dataset cache directory")
+ parser.add_argument("--output-json", type=str, default="benchmark_results/pso_v8_post_training_ensemble.json", help="JSON output path")
+ parser.add_argument("--output-csv", type=str, default="benchmark_results/pso_v8_post_training_ensemble.csv", help="CSV output path")
+ parser.add_argument("--output-png", type=str, default="history_plt/pso_v8_post_training_ensemble.png", help="PNG output path")
+
+ args = parser.parse_args()
+
+ run_post_training_study(
+ cache_dir=args.cache_dir,
+ device=args.device,
+ output_json=args.output_json,
+ output_csv=args.output_csv,
+ output_png=args.output_png,
+ )
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/post_training_resnet_convergence.py b/test/post_training_resnet_convergence.py
new file mode 100644
index 0000000..a95f763
--- /dev/null
+++ b/test/post_training_resnet_convergence.py
@@ -0,0 +1,1178 @@
+"""CIFAR-10 ResNet adapters for the post-training model-convergence protocol.
+
+The module deliberately keeps torchvision imports lazy: importing the common
+registry must not construct a dataset or download anything. All persistence
+is scoped to a caller supplied run root and all public-test access is guarded
+by the common frozen-manifest seal.
+"""
+from __future__ import annotations
+
+import contextlib
+import dataclasses
+import hashlib
+import io
+import json
+import math
+import os
+import random
+import time
+from pathlib import Path
+from typing import Any, Iterable, Iterator, Mapping, Sequence
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, Dataset
+
+from test.post_training_model_convergence import (
+ BASE_SEEDS,
+ PROJECTION_SEED,
+ OBJECTIVE_CHECKPOINTS,
+ PSO_GENERATIONS,
+ RANDOM_CANDIDATES,
+ RESIDUAL_DIMENSION,
+ SWARM_SEEDS,
+ AuditResult,
+ ObjectiveResult,
+ ProtocolError,
+ ResourceCounters,
+ SealError,
+ SelectedResidualCodec,
+ StudyConfig,
+ StudyState,
+ StudyStateMachine,
+ atomic_write_bytes,
+ atomic_write_json,
+ begin_confirmation,
+ canonical_json,
+ fingerprint_file,
+ fingerprint_module,
+ fingerprint_paths,
+ fingerprint_nonselected_state,
+ finish_confirmation,
+ freeze_run,
+ load_frozen_manifest,
+ load_state,
+ persist_state,
+ prepare_run,
+ run_equal_budget_random,
+ run_residual_pso,
+ run_state_neutral_audit,
+ select_endpoint,
+ sha256_bytes,
+ verify_frozen_manifest,
+)
+
+
+WORKLOAD_IDS = ("cifar10_resnet18", "cifar10_resnet50")
+ARCHITECTURES = {"cifar10_resnet18": "resnet18", "cifar10_resnet50": "resnet50"}
+TRAIN_SAMPLES = 50_000
+SPLIT_COUNTS = {"bp_train": 35_000, "refine_search": 5_000, "selection_val": 10_000}
+OBJECTIVE_SAMPLES = 1_024
+BATCH_SIZE = 128
+TRAIN_EPOCHS = 100
+SMOKE_EPOCHS = 2
+SMOKE_BATCH_SIZE = 8
+SMOKE_OBJECTIVE_SAMPLES = 16
+SMOKE_SEARCH_GENERATIONS = 2
+SMOKE_SEARCH_PARTICLES = 12
+
+
+class TestSealError(SealError):
+ """Raised when official CIFAR test data is opened before confirmation."""
+
+
+class CIFARSubset(Dataset[tuple[torch.Tensor, torch.Tensor]]):
+ def __init__(self, images: torch.Tensor, labels: torch.Tensor, indices: Sequence[int], *, augment: bool = False) -> None:
+ self.images = images
+ self.labels = labels
+ self.indices = tuple(int(i) for i in indices)
+ self.augment = augment
+
+ def __len__(self) -> int:
+ return len(self.indices)
+
+ def __getitem__(self, index: int) -> tuple[torch.Tensor, torch.Tensor]:
+ image = self.images[self.indices[index]]
+ if self.augment:
+ # CIFAR augmentation is intentionally implemented without a global
+ # torchvision transform object so loader RNG ownership is explicit.
+ pad = F.pad(image.unsqueeze(0), (4, 4, 4, 4), mode="reflect").squeeze(0)
+ top = int(torch.randint(0, 9, ()).item())
+ left = int(torch.randint(0, 9, ()).item())
+ image = pad[:, top : top + 32, left : left + 32]
+ if bool(torch.rand(()) < 0.5):
+ image = image.flip(-1)
+ return image, self.labels[self.indices[index]]
+
+
+def _seed_everything(seed: int) -> None:
+ random.seed(seed)
+ np.random.seed(seed)
+ torch.manual_seed(seed)
+ if torch.cuda.is_available():
+ torch.cuda.manual_seed_all(seed)
+
+
+def make_cifar_resnet(architecture: str, seed: int = 501) -> nn.Module:
+ """Construct the exact scratch CIFAR stem and requested torchvision model."""
+ if architecture not in {"resnet18", "resnet50"}:
+ raise ProtocolError(f"unsupported ResNet architecture: {architecture}")
+ from torchvision import models
+
+ _seed_everything(seed)
+ constructor = getattr(models, architecture)
+ model = constructor(weights=None, num_classes=10)
+ model.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
+ model.maxpool = nn.Identity()
+ if model.conv1.kernel_size != (3, 3) or model.conv1.stride != (1, 1):
+ raise ProtocolError("CIFAR stem was not installed")
+ return model
+
+
+def selected_parameter_names(model: nn.Module, architecture: str) -> tuple[str, ...]:
+ block = "layer4.1" if architecture == "resnet18" else "layer4.2"
+ names = tuple(name for name, value in model.named_parameters() if name.startswith(block + ".") and value.is_floating_point())
+ if not names:
+ raise ProtocolError(f"selected block has no floating parameters: {block}")
+ if any(name.startswith("layer4.") and not name.startswith(block + ".") for name in names):
+ raise ProtocolError("selected-name topology mismatch")
+ return names
+
+
+def head_parameter_names(model: nn.Module) -> tuple[str, ...]:
+ names = tuple(name for name, _ in model.named_parameters() if name in {"fc.weight", "fc.bias"})
+ if names != ("fc.weight", "fc.bias"):
+ raise ProtocolError(f"unexpected CIFAR head parameters: {names}")
+ return names
+
+
+def _canonical_pixel_hash(image: np.ndarray) -> str:
+ value = np.asarray(image, dtype=np.uint8)
+ if value.shape != (32, 32, 3):
+ raise ProtocolError(f"unexpected CIFAR image shape: {value.shape}")
+ payload = b"RGB32\0" + canonical_json((32, 32, 3)) + value.tobytes(order="C")
+ return hashlib.sha256(payload).hexdigest()
+
+
+def _initial_stratified_assignment(labels: np.ndarray, seed: int) -> tuple[list[int], dict[int, str]]:
+ generator = np.random.default_rng(seed)
+ bucket = np.full(len(labels), "", dtype=object)
+ global_order: list[int] = []
+ for cls in range(10):
+ members = np.flatnonzero(labels == cls)
+ members = members[generator.permutation(len(members))]
+ global_order.extend(int(i) for i in members)
+ bucket[members[:3500]] = "bp_train"
+ bucket[members[3500:4000]] = "refine_search"
+ bucket[members[4000:5000]] = "selection_val"
+ if any(not item for item in bucket):
+ raise ProtocolError("stratified CIFAR assignment did not cover train set")
+ rank = {index: position for position, index in enumerate(global_order)}
+ return [int(i) for i in global_order], {int(i): str(bucket[i]) for i in range(len(labels))}
+
+
+def build_cifar_manifests(images: np.ndarray, labels: Sequence[int], *, split_seed: int = 20260908) -> dict[str, Any]:
+ """Build deterministic duplicate-group-aware CIFAR role manifests."""
+ pixels = np.asarray(images)
+ y = np.asarray(labels, dtype=np.int64)
+ if pixels.shape != (TRAIN_SAMPLES, 32, 32, 3) or y.shape != (TRAIN_SAMPLES,):
+ raise ProtocolError(f"expected CIFAR train shape (50000,32,32,3), got {pixels.shape}, {y.shape}")
+ if int(y.min()) != 0 or int(y.max()) != 9:
+ raise ProtocolError("CIFAR labels must be in [0,9]")
+ order, assignment = _initial_stratified_assignment(y, split_seed)
+ groups: dict[str, list[int]] = {}
+ for index in range(len(y)):
+ groups.setdefault(_canonical_pixel_hash(pixels[index]), []).append(index)
+ rank = {index: position for position, index in enumerate(order)}
+ invalid: list[dict[str, Any]] = []
+ moved = 0
+ for digest, members in groups.items():
+ classes = {int(y[i]) for i in members}
+ if len(classes) != 1:
+ invalid.append({"fingerprint": digest, "indices": members, "labels": sorted(classes)})
+ continue
+ owner = assignment[min(members, key=lambda i: rank[i])]
+ for index in members:
+ if assignment[index] != owner:
+ moved += 1
+ assignment[index] = owner
+ if invalid:
+ raise ProtocolError(f"duplicate pixels have conflicting labels: {invalid[:2]}")
+ split_indices = {role: [index for index in order if assignment[index] == role] for role in SPLIT_COUNTS}
+ # Group ownership is primary; exact cardinality may therefore change.
+ for role, expected in SPLIT_COUNTS.items():
+ if not split_indices[role]:
+ raise ProtocolError(f"empty CIFAR role: {role}")
+ if role == "bp_train" and len(split_indices[role]) < 30_000:
+ raise ProtocolError("duplicate grouping changed bp_train implausibly")
+ refine_by_class = {cls: [i for i in split_indices["refine_search"] if int(y[i]) == cls] for cls in range(10)}
+ objective: list[int] = []
+ for cls in range(10):
+ need = 103 if cls < 4 else 102
+ if len(refine_by_class[cls]) < need:
+ raise ProtocolError(f"insufficient refine_search class {cls} examples")
+ objective.extend(refine_by_class[cls][:need])
+ if len(objective) != OBJECTIVE_SAMPLES:
+ raise ProtocolError("CIFAR objective does not contain exactly 1024 examples")
+ return {
+ "dataset": "cifar10",
+ "split_seed": int(split_seed),
+ "source_train_samples": TRAIN_SAMPLES,
+ "roles": {role: [int(i) for i in values] for role, values in split_indices.items()},
+ "objective": [int(i) for i in objective],
+ "counts": {role: len(values) for role, values in split_indices.items()},
+ "duplicate_groups": len(groups),
+ "duplicate_members_moved": moved,
+ "duplicate_group_hashes": sorted(groups),
+ "normalization_scope": "bp_train_only",
+ }
+
+
+def prepare_cifar_data(data_root: str | os.PathLike[str], *, split_seed: int = 20260908, allow_download: bool = False) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any], dict[str, Any]]:
+ """Load only official CIFAR training data and create the development manifest."""
+ from torchvision.datasets import CIFAR10
+
+ root = Path(data_root)
+ root.mkdir(parents=True, exist_ok=True)
+ dataset = CIFAR10(root=str(root), train=True, download=allow_download)
+ raw_images = np.asarray(dataset.data, dtype=np.uint8)
+ labels = np.asarray(dataset.targets, dtype=np.int64)
+ manifest = build_cifar_manifests(raw_images, labels, split_seed=split_seed)
+ bp = np.asarray(manifest["roles"]["bp_train"], dtype=np.int64)
+ pixels = torch.from_numpy(raw_images).permute(0, 3, 1, 2).contiguous().float().div_(255.0)
+ mean = pixels[bp].mean(dim=(0, 2, 3))
+ std = pixels[bp].std(dim=(0, 2, 3), unbiased=False).clamp_min(1e-12)
+ normalized = (pixels - mean[None, :, None, None]) / std[None, :, None, None]
+ provenance = {
+ "source": "torchvision.datasets.CIFAR10(train=True)",
+ "train_samples": len(dataset),
+ "mean": [float(x) for x in mean],
+ "std": [float(x) for x in std],
+ "normalization_scope": "bp_train_only",
+ "data_sha256": hashlib.sha256(raw_images.tobytes(order="C")).hexdigest(),
+ }
+ manifest["normalization"] = provenance
+ return normalized, torch.from_numpy(labels), manifest, provenance
+
+
+def _assert_test_sealed(run_root: Path) -> None:
+ state = load_state(run_root)
+ if state.state not in {StudyState.FROZEN, StudyState.CONFIRMING, StudyState.COMPLETED}:
+ raise TestSealError("official CIFAR test access is forbidden before frozen state")
+ verify_frozen_manifest(run_root)
+
+
+def load_official_test_data(data_root: str | os.PathLike[str], run_root: str | os.PathLike[str], *, allow_download: bool = False, mean: Sequence[float] | None = None, std: Sequence[float] | None = None) -> tuple[torch.Tensor, torch.Tensor]:
+ """Construct the official test dataset exactly behind the frozen seal."""
+ _assert_test_sealed(Path(run_root))
+ from torchvision.datasets import CIFAR10
+
+ dataset = CIFAR10(root=str(data_root), train=False, download=allow_download)
+ if len(dataset) != 10_000:
+ raise ProtocolError(f"official CIFAR test must contain 10000 samples, got {len(dataset)}")
+ images = torch.from_numpy(np.asarray(dataset.data, dtype=np.uint8)).permute(0, 3, 1, 2).contiguous().float().div_(255.0)
+ labels = torch.as_tensor(dataset.targets, dtype=torch.long)
+ if mean is not None and std is not None:
+ images = (images - torch.as_tensor(mean)[None, :, None, None]) / torch.as_tensor(std)[None, :, None, None]
+ return images, labels
+
+
+def audit_test_duplicates(train_images: np.ndarray, test_images: np.ndarray) -> dict[str, Any]:
+ train_hashes = {_canonical_pixel_hash(image) for image in np.asarray(train_images)}
+ test_hashes = [_canonical_pixel_hash(image) for image in np.asarray(test_images)]
+ overlap = sorted(train_hashes.intersection(test_hashes))
+ return {"train_unique": len(train_hashes), "test_unique": len(set(test_hashes)), "exact_duplicate_groups": len(overlap), "exact_duplicate": bool(overlap), "overlap_hashes": overlap}
+
+
+def _prefix(model: nn.Module, x: torch.Tensor, block_index: int) -> torch.Tensor:
+ x = model.conv1(x)
+ x = model.bn1(x)
+ x = model.relu(x)
+ x = model.maxpool(x)
+ x = model.layer1(x)
+ x = model.layer2(x)
+ x = model.layer3(x)
+ for index in range(block_index):
+ x = model.layer4[index](x)
+ return x
+
+
+def _suffix(model: nn.Module, x: torch.Tensor, block_index: int) -> torch.Tensor:
+ for index in range(block_index, len(model.layer4)):
+ x = model.layer4[index](x)
+ x = model.avgpool(x)
+ x = torch.flatten(x, 1)
+ return model.fc(x)
+
+
+def _avgpool_features(model: nn.Module, x: torch.Tensor, block_index: int) -> torch.Tensor:
+ for index in range(block_index, len(model.layer4)):
+ x = model.layer4[index](x)
+ return torch.flatten(model.avgpool(x), 1)
+
+
+def classification_metrics(logits: torch.Tensor, labels: torch.Tensor) -> dict[str, float]:
+ logits_cpu = logits.detach().cpu().to(torch.float64)
+ log_prob = F.log_softmax(logits_cpu, dim=1)
+ target = labels.detach().cpu().to(torch.long)
+ nll = -log_prob[torch.arange(target.numel()), target].mean()
+ accuracy = (logits_cpu.argmax(dim=1) == target).to(torch.float64).mean()
+ return {
+ "nll": float(nll),
+ "accuracy": float(accuracy),
+ "samples": int(target.numel()),
+ }
+
+
+def _probability_metrics(probabilities: np.ndarray, labels: np.ndarray) -> dict[str, float]:
+ p = np.asarray(probabilities, dtype=np.float64)
+ y = np.asarray(labels, dtype=np.int64)
+ if p.ndim != 2 or len(p) != len(y):
+ raise ProtocolError("probability/label shape mismatch")
+ nll = -np.log(np.clip(p[np.arange(len(y)), y], 1e-300, 1.0)).mean()
+ return {"nll": float(nll), "accuracy": float((p.argmax(axis=1) == y).mean()), "samples": int(len(y))}
+
+
+def evaluate_logits(model: nn.Module, images: torch.Tensor, labels: torch.Tensor, device: torch.device | str, *, batch_size: int = 512) -> tuple[dict[str, float], np.ndarray]:
+ model_device = torch.device(device)
+ model.to(model_device).eval()
+ probs: list[np.ndarray] = []
+ with torch.no_grad():
+ for start in range(0, len(images), batch_size):
+ logits = model(images[start : start + batch_size].to(model_device))
+ probs.append(
+ torch.softmax(logits, dim=1)
+ .cpu()
+ .to(torch.float64)
+ .numpy()
+ )
+ values = np.concatenate(probs, axis=0)
+ return _probability_metrics(values, labels.cpu().numpy()), values
+
+
+@dataclasses.dataclass
+class ResNetCache:
+ prefixes: tuple[torch.Tensor, ...]
+ labels: torch.Tensor
+ block_index: int
+ source_fingerprint: str
+ batch_size: int
+
+ @classmethod
+ def build(cls, model: nn.Module, images: torch.Tensor, labels: torch.Tensor, block_index: int, *, batch_size: int = 64) -> "ResNetCache":
+ chunks: list[torch.Tensor] = []
+ model.eval()
+ with torch.no_grad():
+ for start in range(0, len(images), batch_size):
+ chunks.append(_prefix(model, images[start : start + batch_size].to(next(model.parameters()).device), block_index).detach().cpu().clone())
+ return cls(tuple(chunks), labels.detach().cpu().clone(), block_index, hashlib.sha256(images.detach().cpu().contiguous().numpy().tobytes()).hexdigest(), batch_size)
+
+ @property
+ def samples(self) -> int:
+ return int(self.labels.numel())
+
+
+class CachedSuffixEvaluator:
+ """Evaluate the real mutable block and suffix against a detached prefix cache."""
+ def __init__(self, model: nn.Module, cache: ResNetCache, device: torch.device | str) -> None:
+ self.model = model
+ self.cache = cache
+ self.device = torch.device(device)
+ self.model.to(self.device)
+
+ def logits(self, *, grad: bool = False) -> torch.Tensor:
+ output: list[torch.Tensor] = []
+ context = contextlib.nullcontext() if grad else torch.no_grad()
+ with context:
+ for prefix in self.cache.prefixes:
+ output.append(_suffix(self.model, prefix.to(self.device), self.cache.block_index))
+ return torch.cat(output, dim=0)
+
+ def objective(self, residual: torch.Tensor | None = None, codec: SelectedResidualCodec | None = None) -> ObjectiveResult:
+ try:
+ if residual is not None and codec is not None:
+ with codec.applied(self.model, residual):
+ logits = self.logits()
+ else:
+ logits = self.logits()
+ stats = classification_metrics(logits, self.cache.labels.to(self.device))
+ return ObjectiveResult(stats["nll"], self.cache.samples, forward_passes=len(self.cache.prefixes))
+ finally:
+ if codec is not None:
+ codec.restore_base(self.model)
+
+ def validation(self, residual: torch.Tensor | None = None, codec: SelectedResidualCodec | None = None) -> AuditResult:
+ if residual is not None and codec is not None:
+ with codec.applied(self.model, residual):
+ stats = classification_metrics(self.logits(), self.cache.labels.to(self.device))
+ else:
+ stats = classification_metrics(self.logits(), self.cache.labels.to(self.device))
+ return AuditResult(stats["nll"], stats["accuracy"], self.cache.samples, metadata={"nll": stats["nll"], "accuracy": stats["accuracy"]})
+
+
+def cached_residual_parity(model: nn.Module, images: torch.Tensor, cache: ResNetCache, codec: SelectedResidualCodec, residual: torch.Tensor, *, atol: float = 1e-6, rtol: float = 1e-5) -> dict[str, Any]:
+ """Compare one nonzero candidate's cached suffix with a full forward."""
+ dev = next(model.parameters()).device
+ with codec.applied(model, residual):
+ with torch.no_grad():
+ full = model(images.to(dev)).cpu()
+ cached = torch.cat([_suffix(model, item.to(dev), cache.block_index).cpu() for item in cache.prefixes])
+ difference = float((full - cached).abs().max()) if full.numel() else 0.0
+ return {"passed": bool(torch.allclose(full, cached, atol=atol, rtol=rtol)), "max_abs_difference": difference, "samples": len(images)}
+
+
+
+def _save_torch(path: Path, value: Any) -> str:
+ stream = io.BytesIO()
+ torch.save(value, stream)
+ atomic_write_bytes(path, stream.getvalue())
+ return fingerprint_file(path)
+
+
+def _state_cpu(model: nn.Module) -> dict[str, torch.Tensor]:
+ return {name: value.detach().cpu().clone() for name, value in model.state_dict().items()}
+
+
+def train_baseline(model: nn.Module, images: torch.Tensor, labels: torch.Tensor, manifest: Mapping[str, Any], *, seed: int, device: torch.device | str, epochs: int = TRAIN_EPOCHS, batch_size: int = BATCH_SIZE, checkpoint_path: Path | None = None, counters: ResourceCounters | None = None) -> dict[str, Any]:
+ _seed_everything(seed)
+ dev = torch.device(device)
+ model.to(dev)
+ bp_indices = manifest["roles"]["bp_train"]
+ selection_indices = manifest["roles"]["selection_val"]
+ train_loader = DataLoader(CIFARSubset(images, labels, bp_indices, augment=True), batch_size=batch_size, shuffle=True, generator=torch.Generator().manual_seed(seed + 1000), num_workers=0)
+ optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)
+ scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)
+ criterion = nn.CrossEntropyLoss()
+ telemetry: list[dict[str, Any]] = []
+ audit_indices = bp_indices[: min(1024, len(bp_indices))]
+ for epoch in range(1, epochs + 1):
+ model.train()
+ for batch_x, batch_y in train_loader:
+ optimizer.zero_grad(set_to_none=True)
+ logits = model(batch_x.to(dev))
+ loss = criterion(logits, batch_y.to(dev))
+ if not bool(torch.isfinite(loss).item()):
+ raise RuntimeError(f"non-finite baseline loss at epoch {epoch}")
+ loss.backward()
+ optimizer.step()
+ if counters is not None:
+ counters.base_training_samples += int(batch_y.numel())
+ counters.base_training_forward_passes += 1
+ counters.base_training_backward_passes += 1
+ scheduler.step()
+ if epoch >= max(1, epochs - 10) or epochs <= SMOKE_EPOCHS:
+ def audit() -> dict[str, Any]:
+ train_stats, _ = evaluate_logits(model, images[audit_indices], labels[audit_indices], dev, batch_size=batch_size)
+ val_stats, _ = evaluate_logits(model, images[selection_indices], labels[selection_indices], dev, batch_size=batch_size)
+ return {"epoch": epoch, "audit": train_stats, "selection": val_stats, "lr": float(optimizer.param_groups[0]["lr"])}
+ telemetry.append(run_state_neutral_audit(model, audit))
+ final_state = _state_cpu(model)
+ checkpoint_hash = None
+ if checkpoint_path is not None:
+ checkpoint_hash = _save_torch(checkpoint_path, {"state_dict": final_state, "seed": seed, "epoch": epochs, "architecture": model.__class__.__name__})
+ losses = [float(item["selection"]["nll"]) for item in telemetry]
+ metrics = [float(item["selection"]["accuracy"]) for item in telemetry]
+ mean_loss = max(abs(float(np.mean(losses))), 1e-12) if losses else 1.0
+ plateau = bool(losses and (max(losses) - min(losses)) / mean_loss <= 0.01 and (max(metrics) - min(metrics)) <= 0.005)
+ return {"seed": seed, "epochs": epochs, "checkpoint": str(checkpoint_path) if checkpoint_path else None, "checkpoint_hash": checkpoint_hash, "state_dict": final_state, "telemetry": telemetry, "baseline_plateau": plateau, "final_metrics": telemetry[-1] if telemetry else None, "batch_size": batch_size}
+
+
+def _feature_cache_objective(model: nn.Module, cache: ResNetCache, codec: SelectedResidualCodec, residual: torch.Tensor) -> ObjectiveResult:
+ evaluator = CachedSuffixEvaluator(model, cache, next(model.parameters()).device)
+ return evaluator.objective(residual, codec)
+
+
+def _head_cache(model: nn.Module, images: torch.Tensor, block_index: int, device: torch.device | str, batch_size: int = 64) -> tuple[tuple[torch.Tensor, ...], torch.Tensor]:
+ features: list[torch.Tensor] = []
+ model.to(device).eval()
+ with torch.no_grad():
+ for start in range(0, len(images), batch_size):
+ prefix = _prefix(model, images[start : start + batch_size].to(device), block_index)
+ features.append(_avgpool_features(model, prefix, block_index).detach().cpu())
+ return tuple(features), images
+
+
+def run_feature_adam(model: nn.Module, cache: ResNetCache, names: Sequence[str], *, device: torch.device | str, updates: int = 40, lr: float = 1e-3) -> dict[str, Any]:
+ dev = torch.device(device)
+ selected = dict(model.named_parameters())
+ base = [selected[name].detach().to(dev).clone() for name in names]
+ scales = [0.05 * max(float(torch.sqrt(torch.mean(item * item))), 0.01) for item in base]
+ delta = nn.Parameter(torch.zeros(sum(item.numel() for item in base), device=dev))
+ optimizer = torch.optim.AdamW([delta], lr=lr, betas=(0.9, 0.999), eps=1e-8, weight_decay=0.0)
+ offsets = np.cumsum([0] + [item.numel() for item in base])
+ block_prefix = names[0].split(".")[:2]
+ block = model.layer4[int(block_prefix[1])]
+ local_names = [name.split(".", 2)[2] for name in names]
+ trajectory: list[dict[str, Any]] = []
+ for update in range(updates + 1):
+ if update:
+ optimizer.zero_grad(set_to_none=True)
+ total = torch.zeros((), device=dev, dtype=torch.float32)
+ for prefix, labels in zip(cache.prefixes, cache.labels.split([len(p) for p in cache.prefixes])):
+ overrides: dict[str, torch.Tensor] = {}
+ for index, local_name in enumerate(local_names):
+ part = delta[offsets[index] : offsets[index + 1]].view_as(base[index])
+ bound = scales[index]
+ overrides[local_name] = base[index] + part.clamp(-bound, bound)
+ mutable = torch.func.functional_call(block, overrides, (prefix.to(dev),))
+ x = mutable
+ for index in range(int(block_prefix[1]) + 1, len(model.layer4)):
+ x = model.layer4[index](x)
+ logits = model.fc(torch.flatten(model.avgpool(x), 1))
+ target = labels.to(dev)
+ total = total + F.cross_entropy(
+ logits,
+ target,
+ reduction="sum",
+ )
+ (total / cache.samples).backward()
+ optimizer.step()
+ with torch.no_grad():
+ values = []
+ for index, item in enumerate(base):
+ part = delta[
+ offsets[index] : offsets[index + 1]
+ ].view_as(item)
+ values.append(
+ item
+ + part.clamp(-scales[index], scales[index])
+ )
+ for name, value in zip(names, values):
+ selected[name].copy_(value)
+ stats = CachedSuffixEvaluator(model, cache, dev).validation()
+ trajectory.append({"update": update, "objective": stats.loss, "accuracy": stats.primary_metric})
+ final_parameters = [value.detach().cpu().clone() for value in values]
+ with torch.no_grad():
+ for name, value in zip(names, base):
+ selected[name].copy_(value)
+ return {"method": "feature_adam", "updates": updates, "trajectory": trajectory, "best_residual": delta.detach().cpu().tolist(), "final_parameters": final_parameters, "final": trajectory[-1]}
+
+
+def run_head_adam(model: nn.Module, features: tuple[torch.Tensor, ...], labels: torch.Tensor, *, device: torch.device | str, updates: int = 40, lr: float = 1e-3) -> dict[str, Any]:
+ dev = torch.device(device)
+ weight = model.fc.weight.detach().to(dev).clone()
+ bias = model.fc.bias.detach().to(dev).clone()
+ delta_w = nn.Parameter(torch.zeros_like(weight))
+ delta_b = nn.Parameter(torch.zeros_like(bias))
+ optimizer = torch.optim.AdamW([delta_w, delta_b], lr=lr, betas=(0.9, 0.999), eps=1e-8, weight_decay=0.0)
+ trajectory: list[dict[str, Any]] = []
+ chunks = labels.split([len(x) for x in features])
+ for update in range(updates + 1):
+ if update:
+ optimizer.zero_grad(set_to_none=True)
+ total = torch.zeros((), device=dev, dtype=torch.float32)
+ for feature, target in zip(features, chunks):
+ logits = F.linear(feature.to(dev), weight + delta_w, bias + delta_b)
+ target = target.to(dev)
+ total = total + F.cross_entropy(
+ logits,
+ target,
+ reduction="sum",
+ )
+ (total / len(labels)).backward()
+ optimizer.step()
+ with torch.no_grad():
+ model.fc.weight.copy_(weight + delta_w)
+ model.fc.bias.copy_(bias + delta_b)
+ logits = torch.cat([F.linear(feature.to(dev), model.fc.weight, model.fc.bias) for feature in features])
+ stats = classification_metrics(logits, labels.to(dev))
+ trajectory.append(
+ {
+ "update": update,
+ "objective": stats["nll"],
+ "accuracy": stats["accuracy"],
+ }
+ )
+ final_weight = (weight + delta_w).detach().cpu().clone()
+ final_bias = (bias + delta_b).detach().cpu().clone()
+ with torch.no_grad():
+ model.fc.weight.copy_(weight)
+ model.fc.bias.copy_(bias)
+ return {"method": "head_adam", "updates": updates, "trajectory": trajectory, "final_weight": final_weight, "final_bias": final_bias, "final": trajectory[-1]}
+
+
+def _smoke_search(objective: Any, *, seed: int, device: torch.device | str) -> dict[str, Any]:
+ """Two-generation real PSO movement used only by smoke (production is 12x60)."""
+ rng = np.random.default_rng(seed)
+ positions = [np.zeros(64, dtype=np.float32)]
+ for _ in range(5):
+ value = rng.uniform(-0.25, 0.25, 64).astype(np.float32)
+ positions.extend([value, -value])
+ positions.append(rng.uniform(-0.25, 0.25, 64).astype(np.float32))
+ velocities = [np.zeros(64, dtype=np.float32) for _ in positions]
+ pbest = [value.copy() for value in positions]
+ pbest_loss = [math.inf] * len(positions)
+ gbest = positions[0].copy()
+ gbest_loss = math.inf
+ evaluations = 0
+ for generation in range(1, SMOKE_SEARCH_GENERATIONS + 1):
+ snapshot = [value.copy() for value in positions]
+ for index, candidate in enumerate(snapshot):
+ result = ObjectiveResult.coerce(objective(torch.from_numpy(candidate)))
+ evaluations += 1
+ if result.loss < pbest_loss[index]:
+ pbest_loss[index], pbest[index] = result.loss, candidate.copy()
+ if result.loss < gbest_loss:
+ gbest_loss, gbest = result.loss, candidate.copy()
+ if generation < SMOKE_SEARCH_GENERATIONS:
+ for index in range(len(positions)):
+ r1, r2 = rng.random(64), rng.random(64)
+ velocities[index] = 0.7298 * (velocities[index] + 2.05 * r1 * (pbest[index] - snapshot[index]) + 2.05 * r2 * (gbest - snapshot[index]))
+ positions[index] = np.clip(snapshot[index] + velocities[index], -1.0, 1.0).astype(np.float32)
+ return {"best_objective": float(gbest_loss), "best_residual": gbest.tolist(), "evaluations": evaluations, "generations": SMOKE_SEARCH_GENERATIONS, "movement": "constriction"}
+
+
+def _ensemble_metrics(probabilities: np.ndarray, labels: np.ndarray, weights: np.ndarray) -> dict[str, float]:
+ mixed = np.einsum("m,mnk->nk", weights, probabilities)
+ return _probability_metrics(mixed, labels)
+
+
+def _fit_temperature(probs: np.ndarray, labels: np.ndarray) -> dict[str, Any]:
+ try:
+ from scipy.optimize import minimize_scalar
+ except ImportError as exc:
+ raise ProtocolError("scipy is required for temperature ensemble fitting") from exc
+ uniform = np.asarray(probs, dtype=np.float64).mean(axis=0)
+ evaluations = 0
+ best_probabilities: np.ndarray | None = None
+
+ def objective(temp: float) -> float:
+ nonlocal evaluations, best_probabilities
+ evaluations += 1
+ logits = np.log(np.clip(uniform, 1e-300, 1.0)) / float(temp)
+ shifted = logits - logits.max(axis=1, keepdims=True)
+ scaled = np.exp(shifted)
+ best_probabilities = scaled / scaled.sum(axis=1, keepdims=True)
+ return _probability_metrics(best_probabilities, labels)["nll"]
+
+ result = minimize_scalar(objective, method="bounded", bounds=(0.01, 10.0))
+ if best_probabilities is None:
+ raise ProtocolError("temperature solver returned no candidate")
+ return {"temperature": float(result.x), "metrics": _probability_metrics(best_probabilities, labels), "evaluations": evaluations, "success": bool(result.success), "status": int(result.status)}
+
+
+def cached_avgpool_parity(model: nn.Module, images: torch.Tensor, *, block_index: int, batch_size: int = 64, atol: float = 1e-6, rtol: float = 1e-5) -> dict[str, Any]:
+ """Compare an avgpool cache against the complete feature path."""
+ dev = next(model.parameters()).device
+ model.eval()
+ cached: list[torch.Tensor] = []
+ direct: list[torch.Tensor] = []
+ with torch.no_grad():
+ for start in range(0, len(images), batch_size):
+ batch = images[start : start + batch_size].to(dev)
+ prefix = _prefix(model, batch, block_index)
+ cached.append(_avgpool_features(model, prefix, block_index).cpu())
+ full_prefix = _prefix(model, batch, 0)
+ direct.append(_avgpool_features(model, full_prefix, 0).cpu())
+ lhs, rhs = torch.cat(cached), torch.cat(direct)
+ difference = float((lhs - rhs).abs().max()) if lhs.numel() else 0.0
+ return {"passed": bool(torch.allclose(lhs, rhs, atol=atol, rtol=rtol)), "max_abs_difference": difference, "samples": len(images)}
+
+
+def cached_full_parity(model: nn.Module, images: torch.Tensor, cache: ResNetCache, *, atol: float = 1e-6, rtol: float = 1e-5) -> dict[str, Any]:
+ """Compare cached suffix logits with a complete model forward."""
+ model.eval()
+ dev = next(model.parameters()).device
+ with torch.no_grad():
+ full = model(images.to(dev)).cpu()
+ cached = torch.cat([_suffix(model, item.to(dev), cache.block_index).cpu() for item in cache.prefixes])
+ difference = float((full - cached).abs().max()) if full.numel() else 0.0
+ return {"passed": bool(torch.allclose(full, cached, atol=atol, rtol=rtol)), "max_abs_difference": difference, "samples": len(images)}
+
+
+def _fit_slsqp(probs: np.ndarray, labels: np.ndarray) -> dict[str, Any]:
+ try:
+ from scipy.optimize import minimize
+ except ImportError as exc:
+ raise ProtocolError("scipy is required for SLSQP ensemble fitting") from exc
+ evaluations = 0
+
+ def objective(weights: np.ndarray) -> float:
+ nonlocal evaluations
+ evaluations += 1
+ return _ensemble_metrics(probs, labels, weights)["nll"]
+
+ result = minimize(
+ objective,
+ np.full(len(probs), 1 / len(probs)),
+ method="SLSQP",
+ bounds=[(0.0, 1.0)] * len(probs),
+ constraints={"type": "eq", "fun": lambda weights: float(weights.sum() - 1.0)},
+ options={"ftol": 1e-12, "maxiter": 1000},
+ )
+ weights = np.asarray(result.x, dtype=np.float64)
+ return {"weights": weights.tolist(), "metrics": _ensemble_metrics(probs, labels, weights), "evaluations": evaluations, "success": bool(result.success), "status": int(result.status), "message": str(result.message)}
+
+
+def _ensemble_pso(probs: np.ndarray, labels: np.ndarray, *, seed: int, generations: int = 20, particles: int = 12) -> dict[str, Any]:
+ rng = np.random.default_rng(seed)
+ positions = [np.zeros(3, dtype=np.float64)]
+ for _ in range(5):
+ value = rng.uniform(-0.25, 0.25, 3)
+ positions.extend([value, -value])
+ positions.append(rng.uniform(-0.25, 0.25, 3))
+ velocities = [np.zeros(3, dtype=np.float64) for _ in positions]
+ pbest = [x.copy() for x in positions]
+ pbest_loss = [math.inf] * particles
+ gbest = positions[0].copy()
+ gbest_loss = math.inf
+ trajectory: list[dict[str, Any]] = []
+ for generation in range(1, generations + 1):
+ for index, candidate in enumerate(positions):
+ weights = np.exp(np.clip(candidate, -5, 5) - np.max(np.clip(candidate, -5, 5)))
+ weights /= weights.sum()
+ loss = _ensemble_metrics(probs, labels, weights)["nll"]
+ if loss < pbest_loss[index]:
+ pbest_loss[index], pbest[index] = loss, candidate.copy()
+ if loss < gbest_loss:
+ gbest_loss, gbest = loss, candidate.copy()
+ trajectory.append({"generation": generation, "objective": gbest_loss})
+ if generation == generations:
+ break
+ old = [x.copy() for x in positions]
+ for index in range(particles):
+ r1, r2 = rng.random(3), rng.random(3)
+ velocities[index] = 0.7298 * (velocities[index] + 2.05 * r1 * (pbest[index] - old[index]) + 2.05 * r2 * (gbest - old[index]))
+ positions[index] = np.clip(old[index] + velocities[index], -5, 5)
+ logits = np.exp(gbest - np.max(gbest)); weights = logits / logits.sum()
+ return {"seed": seed, "weights": weights.tolist(), "metrics": _ensemble_metrics(probs, labels, weights), "trajectory": trajectory, "queries": generations * particles}
+def evaluate_fitted_ensemble(fitted: Mapping[str, Any], pool_probabilities: np.ndarray, labels: np.ndarray) -> dict[str, Any]:
+ """Audit objective-fitted ensemble candidates on selection data without refitting."""
+ probabilities = np.asarray(pool_probabilities, dtype=np.float64)
+ labels = np.asarray(labels, dtype=np.int64)
+ uniform = np.full(3, 1 / 3)
+ result: dict[str, Any] = {"uniform": {"metrics": _ensemble_metrics(probabilities, labels, uniform), "weights": uniform.tolist()}}
+ temp_entry = fitted["uniform_temperature"]
+ temp = float(temp_entry["temperature"])
+ uniform_probs = probabilities.mean(axis=0)
+ logits = np.log(np.clip(uniform_probs, 1e-300, 1.0)) / temp
+ scaled = np.exp(logits - logits.max(axis=1, keepdims=True)); scaled /= scaled.sum(axis=1, keepdims=True)
+ result["uniform_temperature"] = {"metrics": _probability_metrics(scaled, labels), "temperature": temp}
+ slsqp_entry = fitted["slsqp_weights"]
+ slsqp_weights = np.asarray(slsqp_entry["weights"], dtype=np.float64)
+ result["slsqp_weights"] = {"metrics": _ensemble_metrics(probabilities, labels, slsqp_weights), "weights": slsqp_weights.tolist()}
+ pso_candidates = []
+ for candidate in fitted["ensemble_pso"]:
+ weights = np.asarray(candidate["weights"], dtype=np.float64)
+ pso_candidates.append({**candidate, "selection_metrics": _ensemble_metrics(probabilities, labels, weights)})
+ result["ensemble_pso"] = pso_candidates
+ return result
+
+
+
+def run_ensemble_methods(pool_probabilities: np.ndarray, labels: np.ndarray, *, swarm_seeds: Sequence[int] = SWARM_SEEDS) -> dict[str, Any]:
+ probabilities = np.asarray(pool_probabilities, dtype=np.float64)
+ if probabilities.ndim != 3 or probabilities.shape[0] != 3:
+ raise ProtocolError("ResNet ensemble pool must have shape (3,N,10)")
+ uniform_weights = np.full(3, 1 / 3)
+ result: dict[str, Any] = {"uniform": {"weights": uniform_weights.tolist(), "metrics": _ensemble_metrics(probabilities, labels, uniform_weights)}}
+ result["uniform_temperature"] = _fit_temperature(probabilities, labels)
+ result["slsqp_weights"] = _fit_slsqp(probabilities, labels)
+ result["ensemble_pso"] = [_ensemble_pso(probabilities, labels, seed=int(seed)) for seed in swarm_seeds]
+ return result
+
+
+def _selection_metric(model: nn.Module, images: torch.Tensor, labels: torch.Tensor, manifest: Mapping[str, Any], device: torch.device | str, *, maximize: bool = False) -> dict[str, float]:
+ indices = manifest["roles"]["selection_val"]
+ metrics, _ = evaluate_logits(model, images[indices], labels[indices], device, batch_size=128)
+ return {"nll": float(metrics["nll"]), "accuracy": float(metrics["accuracy"]), "maximize": bool(maximize)}
+
+class ResNetConvergenceAdapter:
+ def __init__(self, *, workload_id: str, config: StudyConfig | Mapping[str, Any], run_root: str | os.PathLike[str], data_root: str | os.PathLike[str], device: str | torch.device = "cpu", allow_download: bool = False) -> None:
+ if workload_id not in WORKLOAD_IDS:
+ raise ProtocolError(f"unsupported ResNet workload: {workload_id}")
+ self.workload_id = workload_id
+ self.architecture = ARCHITECTURES[workload_id]
+ self.config = config if isinstance(config, StudyConfig) else StudyConfig.from_dict(config)
+ self.run_root = Path(run_root)
+ self.data_root = Path(data_root)
+ self.device = torch.device(device)
+ self.allow_download = bool(allow_download)
+ if str(self.device) not in {"cpu", "mps"}:
+ raise ProtocolError("ResNet device must be cpu or mps")
+
+ def _result_path(self) -> Path:
+ return self.run_root / "workloads" / self.workload_id / "result.json"
+
+ def _write_result(self, result: Mapping[str, Any]) -> dict[str, Any]:
+ path = self._result_path()
+ atomic_write_json(path, result)
+ return dict(result)
+
+ def _base_result(self) -> dict[str, Any]:
+ return {"workload_id": self.workload_id, "family": "classification", "config": self.config.to_dict(), "manifests": {}, "provenance": {"architecture": self.architecture, "device": str(self.device)}, "baselines": {}, "arms": {}, "ensemble": {}, "development_selection": {}, "confirmation": {}, "integrity": {"official_test_opened": False}, "leakage_counters": {"official_test_data_loaded_before_freeze": False, "official_test_evaluations_before_freeze": 0, "official_test_construction": 0, "official_test_evaluations": 0}, "resource_ledger": {}, "artifact_hashes": {}}
+
+ def run_prepare(self) -> dict[str, Any]:
+ state = prepare_run(self.run_root, self.config) if not (self.run_root / "state.json").exists() else load_state(self.run_root)
+ workload_root = self.run_root / "workloads" / self.workload_id
+ workload_root.mkdir(parents=True, exist_ok=True)
+ images, labels, manifest, provenance = prepare_cifar_data(self.data_root, split_seed=self.config.split_seed, allow_download=self.allow_download)
+ atomic_write_json(workload_root / "manifest.json", manifest)
+ atomic_write_json(workload_root / "provenance.json", provenance)
+ result = self._base_result()
+ result["manifests"], result["provenance"] = manifest, provenance | {"architecture": self.architecture, "device": str(self.device)}
+ result["artifact_hashes"] = fingerprint_paths(self.run_root, [workload_root / "manifest.json", workload_root / "provenance.json"])
+ self._write_result(result)
+ persist_state(self.run_root, state)
+ return result
+
+ def _load_prepared(self) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any], dict[str, Any], dict[str, Any]]:
+ workload_root = self.run_root / "workloads" / self.workload_id
+ manifest_path = workload_root / "manifest.json"
+ if not manifest_path.exists():
+ self.run_prepare()
+ images, labels, manifest, provenance = prepare_cifar_data(self.data_root, split_seed=self.config.split_seed, allow_download=False)
+ result = json.loads(self._result_path().read_text()) if self._result_path().exists() else self._base_result()
+ return images, labels, manifest, provenance, result
+
+ def run_smoke(self) -> dict[str, Any]:
+ images, labels, manifest, provenance, result = self._load_prepared()
+ model = make_cifar_resnet(self.architecture, seed=BASE_SEEDS[0])
+ checkpoint = self.run_root / "workloads" / self.workload_id / "smoke-baseline.pt"
+ baseline = train_baseline(model, images, labels, manifest, seed=BASE_SEEDS[0], device=self.device, epochs=SMOKE_EPOCHS, batch_size=SMOKE_BATCH_SIZE, checkpoint_path=checkpoint)
+ reloaded = make_cifar_resnet(self.architecture, seed=BASE_SEEDS[0] + 1)
+ payload = torch.load(checkpoint, map_location="cpu", weights_only=True)
+ reloaded.load_state_dict(payload["state_dict"])
+ block_index = 1 if self.architecture == "resnet18" else 2
+ names = selected_parameter_names(reloaded, self.architecture)
+ codec = SelectedResidualCodec(reloaded, names, projection_seed=PROJECTION_SEED)
+ tiny = manifest["objective"][:SMOKE_OBJECTIVE_SAMPLES]
+ cache = ResNetCache.build(reloaded, images[tiny], labels[tiny], block_index, batch_size=SMOKE_BATCH_SIZE)
+ evaluator = CachedSuffixEvaluator(reloaded, cache, self.device)
+ zero = torch.zeros(64)
+ nonzero = (torch.arange(64, dtype=torch.float32) % 5 - 2) / 10
+ residuals = [zero, nonzero, -nonzero]
+ objective_results = [evaluator.objective(value, codec).to_dict() for value in residuals]
+ parity = cached_full_parity(reloaded, images[tiny], cache)
+ avgpool_parity = cached_avgpool_parity(reloaded, images[tiny], block_index=block_index, batch_size=SMOKE_BATCH_SIZE)
+ search = _smoke_search(lambda residual: evaluator.objective(residual, codec), seed=SWARM_SEEDS[0], device=self.device)
+ _, pool_probs = evaluate_logits(reloaded, images[tiny], labels[tiny], self.device, batch_size=SMOKE_BATCH_SIZE)
+ ensemble = run_ensemble_methods(np.stack([pool_probs, pool_probs, pool_probs]), labels[tiny].numpy())
+ result["integrity"] = {"cache_parity": parity, "avgpool_cache_parity": avgpool_parity, "objective_results": objective_results, "nonzero_changed": len({item["loss"] for item in objective_results}) > 1, "codec_names": list(names), "checkpoint_roundtrip": fingerprint_module(reloaded) == fingerprint_module(model)}
+ result["resource_ledger"]["smoke"] = {"search_queries": search["evaluations"], "real_model": True, "backward_epochs": SMOKE_EPOCHS, "checkpoint": str(checkpoint.relative_to(self.run_root)), "ensemble_methods": sorted(ensemble)}
+ result["leakage_counters"]["official_test_construction"] = 0
+ self._write_result(result)
+ return result
+
+ def run_develop(self) -> dict[str, Any]:
+ state = load_state(self.run_root)
+ if state.state == StudyState.PREPARED:
+ state.transition(StudyState.DEVELOPING)
+ elif state.state != StudyState.DEVELOPING:
+ raise ProtocolError(f"develop requires prepared/developing state, found {state.state.value}")
+ persist_state(self.run_root, state)
+ images, labels, manifest, provenance, result = self._load_prepared()
+ workload_root = self.run_root / "workloads" / self.workload_id
+ block_index = 1 if self.architecture == "resnet18" else 2
+ for seed in BASE_SEEDS:
+ model = make_cifar_resnet(self.architecture, seed=seed)
+ checkpoint = workload_root / f"baseline-{seed}.pt"
+ baseline = train_baseline(model, images, labels, manifest, seed=seed, device=self.device, checkpoint_path=checkpoint)
+ state_dict = baseline.pop("state_dict")
+ result["baselines"][str(seed)] = {**baseline, "checkpoint": str(checkpoint.relative_to(self.run_root)), "state_fingerprint": fingerprint_module(model)}
+ names = selected_parameter_names(model, self.architecture)
+ codec = SelectedResidualCodec(model, names, projection_seed=PROJECTION_SEED)
+ objective_indices = manifest["objective"]
+ objective_cache = ResNetCache.build(model, images[objective_indices], labels[objective_indices], block_index, batch_size=64)
+ selection_cache = ResNetCache.build(model, images[manifest["roles"]["selection_val"]], labels[manifest["roles"]["selection_val"]], block_index, batch_size=128)
+ evaluator = CachedSuffixEvaluator(model, objective_cache, self.device)
+ validation = CachedSuffixEvaluator(model, selection_cache, self.device)
+ for swarm_seed in SWARM_SEEDS:
+ pso = run_residual_pso(lambda residual: evaluator.objective(residual, codec), codec, seed=swarm_seed, model=model, device=self.device, validation=lambda residual: validation.validation(residual, codec), objective_samples=OBJECTIVE_SAMPLES)
+ random_search = run_equal_budget_random(lambda residual: evaluator.objective(residual, codec), codec, seed=swarm_seed, model=model, device=self.device, validation=lambda residual: validation.validation(residual, codec), objective_samples=OBJECTIVE_SAMPLES)
+ pso_record = {"method": "feature_pso", "base_seed": seed, "swarm_seed": swarm_seed, "best_objective": pso.best_objective.to_dict(), "best_residual": pso.best_residual.cpu().tolist(), "endpoints": [endpoint.to_dict(include_vector=True) for endpoint in pso.endpoints if endpoint.generation in OBJECTIVE_CHECKPOINTS], "initial_residual": [0.0] * RESIDUAL_DIMENSION, "trajectory": [dict(item) for item in pso.trajectory], "counters": pso.counters.to_dict(), "failures": list(pso.failures)}
+ random_record = {"method": "feature_random", "base_seed": seed, "swarm_seed": swarm_seed, "best_objective": random_search.best_objective.to_dict(), "best_residual": random_search.best_residual.cpu().tolist(), "endpoints": [endpoint.to_dict(include_vector=True) for endpoint in random_search.endpoints if endpoint.generation in OBJECTIVE_CHECKPOINTS], "initial_residual": [0.0] * RESIDUAL_DIMENSION, "trajectory": [dict(item) for item in random_search.trajectory], "counters": random_search.counters.to_dict(), "failures": list(random_search.failures)}
+ result["arms"].setdefault("feature_pso", {}).setdefault(str(seed), {})[str(swarm_seed)] = pso_record
+ result["arms"].setdefault("feature_random", {}).setdefault(str(seed), {})[str(swarm_seed)] = random_record
+ pso_path = workload_root / f"feature-pso-{seed}-{swarm_seed}.json"
+ random_path = workload_root / f"feature-random-{seed}-{swarm_seed}.json"
+ atomic_write_json(pso_path, pso_record)
+ atomic_write_json(random_path, random_record)
+ # Controls each start from an untouched, independently reconstructed baseline.
+ control_model = make_cifar_resnet(self.architecture, seed=seed + 10_000)
+ control_model.load_state_dict(state_dict)
+ control_cache = ResNetCache.build(control_model, images[objective_indices], labels[objective_indices], block_index, batch_size=64)
+ feature_adam = run_feature_adam(control_model, control_cache, names, device=self.device)
+ with torch.no_grad():
+ for name, value in zip(names, feature_adam["final_parameters"]):
+ dict(control_model.named_parameters())[name].copy_(value.to(next(control_model.parameters()).device))
+ head_model = make_cifar_resnet(self.architecture, seed=seed + 20_000)
+ head_model.load_state_dict(state_dict)
+ head_features, _ = _head_cache(head_model, images[objective_indices], block_index, self.device)
+ head_adam = run_head_adam(head_model, head_features, labels[objective_indices], device=self.device)
+ with torch.no_grad():
+ head_model.fc.weight.copy_(head_adam["final_weight"].to(next(head_model.parameters()).device))
+ head_model.fc.bias.copy_(head_adam["final_bias"].to(next(head_model.parameters()).device))
+ result["arms"].setdefault("feature_adam", {})[str(seed)] = {**feature_adam, "base_seed": seed, "selection_final": _selection_metric(control_model, images, labels, manifest, self.device, maximize=False)}
+ result["arms"].setdefault("head_adam", {})[str(seed)] = {**head_adam, "base_seed": seed, "selection_final": _selection_metric(head_model, images, labels, manifest, self.device, maximize=False)}
+ feature_control_checkpoint = workload_root / f"feature-adam-{seed}.pt"
+ head_control_checkpoint = workload_root / f"head-adam-{seed}.pt"
+ result["arms"]["feature_adam"][str(seed)]["checkpoint"] = str(feature_control_checkpoint.relative_to(self.run_root))
+ result["arms"]["head_adam"][str(seed)]["checkpoint"] = str(head_control_checkpoint.relative_to(self.run_root))
+ result["arms"]["feature_adam"][str(seed)]["checkpoint_hash"] = _save_torch(feature_control_checkpoint, {"state_dict": _state_cpu(control_model), "base_seed": seed})
+ result["arms"]["head_adam"][str(seed)]["checkpoint_hash"] = _save_torch(head_control_checkpoint, {"state_dict": _state_cpu(head_model), "base_seed": seed})
+ atomic_write_json(workload_root / f"feature-adam-{seed}.json", result["arms"]["feature_adam"][str(seed)])
+ atomic_write_json(workload_root / f"head-adam-{seed}.json", result["arms"]["head_adam"][str(seed)])
+ result["integrity"][str(seed)] = {"selected_names": list(names), "selected_total_numel": codec.total_numel, "nonselected_state_fingerprint": fingerprint_nonselected_state(model, names), "objective_cache": objective_cache.source_fingerprint, "selection_cache": selection_cache.source_fingerprint}
+ # Ensemble fit is objective-only; selection_val is audited independently.
+ objective_pool: list[np.ndarray] = []
+ selection_pool: list[np.ndarray] = []
+ objective_labels = labels[manifest["objective"]]
+ selection_labels = labels[manifest["roles"]["selection_val"]]
+ for seed in BASE_SEEDS:
+ model = make_cifar_resnet(self.architecture, seed=seed)
+ payload = torch.load(workload_root / f"baseline-{seed}.pt", map_location="cpu", weights_only=True)
+ model.load_state_dict(payload["state_dict"])
+ _, objective_probs = evaluate_logits(model, images[manifest["objective"]], objective_labels, self.device)
+ _, selection_probs = evaluate_logits(model, images[manifest["roles"]["selection_val"]], selection_labels, self.device)
+ objective_pool.append(objective_probs)
+ selection_pool.append(selection_probs)
+ objective_ensemble = run_ensemble_methods(np.stack(objective_pool), objective_labels.numpy())
+ selection_ensemble = evaluate_fitted_ensemble(objective_ensemble, np.stack(selection_pool), selection_labels.numpy())
+ result["ensemble"] = {}
+ for method in ("uniform", "uniform_temperature", "slsqp_weights", "ensemble_pso"):
+ result["ensemble"][method] = {"objective": objective_ensemble[method], "selection": selection_ensemble[method], "fit_scope": "refine_search"}
+ pso_selection = selection_ensemble["ensemble_pso"]
+ selected_ensemble_pso = min(pso_selection, key=lambda item: (float(item["selection_metrics"]["nll"]), int(item["seed"])))
+ result["development_selection"] = {"ensemble_pso": {"seed": int(selected_ensemble_pso["seed"]), "selection_nll": float(selected_ensemble_pso["selection_metrics"]["nll"]), "weights": list(selected_ensemble_pso["weights"])}}
+ for seed in BASE_SEEDS:
+ model = make_cifar_resnet(self.architecture, seed=seed)
+ payload = torch.load(workload_root / f"baseline-{seed}.pt", map_location="cpu", weights_only=True)
+ model.load_state_dict(payload["state_dict"])
+ selected_for_seed: dict[str, Any] = {}
+ for method in ("feature_pso", "feature_random"):
+ candidates = result["arms"][method][str(seed)]
+ ranked: list[
+ tuple[float, float, int, int, list[float], Mapping[str, Any]]
+ ] = []
+ for swarm_seed, record in candidates.items():
+ trajectory = record.get("trajectory", [])
+ if not trajectory:
+ raise ProtocolError(
+ f"missing trajectory for {method} base {seed}, "
+ f"swarm {swarm_seed}"
+ )
+ endpoint_by_generation = {
+ int(endpoint["generation"]): endpoint["residual"]
+ for endpoint in record.get("endpoints", [])
+ }
+ initial = trajectory[0].get("initial_validation")
+ if isinstance(initial, Mapping):
+ ranked.append(
+ (
+ float(initial["loss"]),
+ -float(initial.get("primary_metric") or 0.0),
+ 0,
+ int(swarm_seed),
+ list(record["initial_residual"]),
+ record,
+ )
+ )
+ for row in trajectory:
+ validation_record = row.get("validation")
+ generation = int(row.get("generation", -1))
+ if not isinstance(validation_record, Mapping):
+ continue
+ if generation not in endpoint_by_generation:
+ raise ProtocolError(
+ f"missing endpoint vector for generation "
+ f"{generation}"
+ )
+ ranked.append(
+ (
+ float(validation_record["loss"]),
+ -float(
+ validation_record.get("primary_metric")
+ or 0.0
+ ),
+ generation,
+ int(swarm_seed),
+ list(endpoint_by_generation[generation]),
+ record,
+ )
+ )
+ if not ranked or any(
+ not math.isfinite(item[0]) for item in ranked
+ ):
+ raise ProtocolError(
+ f"missing finite selection checkpoints for {method} "
+ f"base {seed}"
+ )
+ ranked.sort(key=lambda item: item[:4])
+ (
+ selected_loss,
+ negative_accuracy,
+ selected_generation,
+ selected_swarm,
+ selected_residual,
+ _,
+ ) = ranked[0]
+ codec = SelectedResidualCodec(
+ model,
+ names,
+ projection_seed=PROJECTION_SEED,
+ )
+ residual = torch.as_tensor(
+ selected_residual,
+ dtype=torch.float32,
+ )
+ codec.apply_residual(model, residual)
+ selected_checkpoint = (
+ workload_root / f"selected-{method}-{seed}.pt"
+ )
+ selected_hash = _save_torch(
+ selected_checkpoint,
+ {
+ "state_dict": _state_cpu(model),
+ "residual": residual,
+ "base_seed": seed,
+ "swarm_seed": selected_swarm,
+ "generation": selected_generation,
+ },
+ )
+ selected_for_seed[method] = {
+ "method": method,
+ "base_seed": seed,
+ "swarm_seed": selected_swarm,
+ "generation": selected_generation,
+ "selection_nll": selected_loss,
+ "selection_accuracy": -negative_accuracy,
+ "residual": residual.tolist(),
+ "checkpoint": str(
+ selected_checkpoint.relative_to(self.run_root)
+ ),
+ "checkpoint_hash": selected_hash,
+ "all_checkpoint_selection_nll": {
+ f"{item[3]}:{item[2]}": item[0] for item in ranked
+ },
+ }
+ codec.restore_base(model)
+ result["development_selection"][str(seed)] = selected_for_seed
+ arm_files = sorted(path for path in workload_root.glob("*.json") if path.name not in {"result.json", "manifest.json", "provenance.json"})
+ artifact_paths = [workload_root / "manifest.json", workload_root / "provenance.json"] + [workload_root / f"baseline-{seed}.pt" for seed in BASE_SEEDS] + [workload_root / f"selected-feature_pso-{seed}.pt" for seed in BASE_SEEDS] + [workload_root / f"selected-feature_random-{seed}.pt" for seed in BASE_SEEDS] + [workload_root / f"feature-adam-{seed}.pt" for seed in BASE_SEEDS] + [workload_root / f"head-adam-{seed}.pt" for seed in BASE_SEEDS] + arm_files
+ relative_artifacts = [str(path.relative_to(self.run_root)) for path in artifact_paths]
+ result["artifact_hashes"] = fingerprint_paths(self.run_root, relative_artifacts)
+ result["integrity"]["official_test_opened"] = False
+ self._write_result(result)
+ persist_state(self.run_root, state)
+ return result
+
+ def run_confirm(self) -> dict[str, Any]:
+ state = load_state(self.run_root)
+ begin_confirmation(self.run_root, state)
+ persist_state(self.run_root, state)
+ images, labels, manifest, provenance, result = self._load_prepared()
+ mean, std = provenance["mean"], provenance["std"]
+ test_images, test_labels = load_official_test_data(self.data_root, self.run_root, allow_download=self.allow_download, mean=mean, std=std)
+ workload_root = self.run_root / "workloads" / self.workload_id
+ # The fingerprint audit uses the decoded test bytes exactly once, after the seal.
+ train_raw = ((images * torch.as_tensor(std)[None, :, None, None] + torch.as_tensor(mean)[None, :, None, None]) * 255.0).round().clamp(0, 255).to(torch.uint8).permute(0, 2, 3, 1).numpy()
+ test_raw = ((test_images * torch.as_tensor(std)[None, :, None, None] + torch.as_tensor(mean)[None, :, None, None]) * 255.0).round().clamp(0, 255).to(torch.uint8).permute(0, 2, 3, 1).numpy()
+ confirmation: dict[str, Any] = {"test_samples": len(test_labels), "base": {}, "selected_feature_pso": {}, "selected_feature_random": {}, "arms": {}, "ensemble": {}, "test_construction": 1, "duplicate_audit": audit_test_duplicates(train_raw, test_raw)}
+ test_pool: list[np.ndarray] = []
+ test_forward_passes = 0
+ for seed in BASE_SEEDS:
+ base_model = make_cifar_resnet(self.architecture, seed=seed)
+ payload = torch.load(workload_root / f"baseline-{seed}.pt", map_location="cpu", weights_only=True)
+ base_model.load_state_dict(payload["state_dict"])
+ base_metrics, base_probs = evaluate_logits(base_model, test_images, test_labels, self.device)
+ test_forward_passes += 1
+ test_pool.append(base_probs)
+ base_prediction_path = workload_root / f"test-predictions-base-{seed}.pt"
+ confirmation["base"][str(seed)] = {"metrics": base_metrics, "prediction_artifact": str(base_prediction_path.relative_to(self.run_root))}
+ _save_torch(base_prediction_path, {"probabilities": base_probs, "targets": test_labels.cpu()})
+ selected_metrics_by_method: dict[str, dict[str, float]] = {}
+ for method in ("feature_pso", "feature_random"):
+ selected_payload = torch.load(workload_root / f"selected-{method}-{seed}.pt", map_location="cpu", weights_only=True)
+ selected_model = make_cifar_resnet(self.architecture, seed=seed + 1)
+ selected_model.load_state_dict(selected_payload["state_dict"])
+ selected_metrics, selected_probs = evaluate_logits(selected_model, test_images, test_labels, self.device)
+ test_forward_passes += 1
+ selected_metrics_by_method[method] = selected_metrics
+ prediction_path = workload_root / f"test-predictions-selected-{method}-{seed}.pt"
+ confirmation.setdefault(f"selected_{method}", {})[str(seed)] = {"metrics": selected_metrics, "prediction_artifact": str(prediction_path.relative_to(self.run_root))}
+ _save_torch(prediction_path, {"probabilities": selected_probs, "targets": test_labels.cpu(), "residual": selected_payload["residual"]})
+ arm_confirmation: dict[str, Any] = {"feature_pso": {}, "feature_random": {}, "feature_adam": {}, "head_adam": {}}
+ for method in ("feature_adam", "head_adam"):
+ control_payload = torch.load(workload_root / f"{method.replace('_', '-')}-{seed}.pt", map_location="cpu", weights_only=True)
+ control_model = make_cifar_resnet(self.architecture, seed=seed)
+ control_model.load_state_dict(control_payload["state_dict"])
+ arm_metrics, arm_probs = evaluate_logits(control_model, test_images, test_labels, self.device)
+ test_forward_passes += 1
+ prediction_path = workload_root / f"test-predictions-{method}-{seed}.pt"
+ arm_confirmation[method] = {"metrics": arm_metrics, "base_seed": seed, "prediction_artifact": str(prediction_path.relative_to(self.run_root))}
+ _save_torch(prediction_path, {"probabilities": arm_probs, "targets": test_labels.cpu()})
+ for method in ("feature_pso", "feature_random"):
+ selected = result["development_selection"][str(seed)][method]
+ prediction_path = workload_root / f"test-predictions-selected-{method}-{seed}.pt"
+ arm_confirmation[method][str(selected["swarm_seed"])] = {"metrics": selected_metrics_by_method[method], "base_seed": seed, "swarm_seed": selected["swarm_seed"], "prediction_artifact": str(prediction_path.relative_to(self.run_root))}
+ confirmation["arms"][str(seed)] = arm_confirmation
+ test_pool_array = np.stack(test_pool)
+ test_labels_np = test_labels.numpy()
+ pool_prediction_path = workload_root / "test-predictions-base-pool.pt"
+ _save_torch(pool_prediction_path, {"probabilities": test_pool_array, "targets": test_labels.cpu()})
+ pool_artifact = str(pool_prediction_path.relative_to(self.run_root))
+ uniform = np.full(3, 1 / 3)
+ uniform_probs = np.einsum("m,mnk->nk", uniform, test_pool_array)
+ uniform_path = workload_root / "test-predictions-ensemble-uniform.pt"
+ _save_torch(uniform_path, {"probabilities": uniform_probs, "targets": test_labels.cpu(), "weights": uniform})
+ confirmation["ensemble"]["uniform"] = {"metrics": _probability_metrics(uniform_probs, test_labels_np), "weights": uniform.tolist(), "prediction_artifact": str(uniform_path.relative_to(self.run_root))}
+ for method, entry in result.get("ensemble", {}).items():
+ if method == "uniform":
+ continue
+ objective_entry = entry.get("objective", {}) if isinstance(entry, Mapping) else {}
+ if method == "slsqp_weights" and objective_entry.get("weights"):
+ weights = np.asarray(objective_entry["weights"], dtype=np.float64)
+ mixed = np.einsum("m,mnk->nk", weights, test_pool_array)
+ path = workload_root / "test-predictions-ensemble-slsqp_weights.pt"
+ _save_torch(path, {"probabilities": mixed, "targets": test_labels.cpu(), "weights": weights})
+ confirmation["ensemble"][method] = {"metrics": _probability_metrics(mixed, test_labels_np), "weights": weights.tolist(), "prediction_artifact": str(path.relative_to(self.run_root))}
+ elif method == "uniform_temperature" and objective_entry.get("temperature"):
+ temp = float(objective_entry["temperature"])
+ logits = np.log(np.clip(uniform_probs, 1e-300, 1.0)) / temp
+ scaled = np.exp(logits - logits.max(axis=1, keepdims=True)); scaled /= scaled.sum(axis=1, keepdims=True)
+ path = workload_root / "test-predictions-ensemble-uniform_temperature.pt"
+ _save_torch(path, {"probabilities": scaled, "targets": test_labels.cpu(), "temperature": temp})
+ confirmation["ensemble"][method] = {"metrics": _probability_metrics(scaled, test_labels_np), "temperature": temp, "prediction_artifact": str(path.relative_to(self.run_root))}
+ elif method == "ensemble_pso" and objective_entry:
+ candidates = objective_entry if isinstance(objective_entry, list) else [objective_entry]
+ selected_seed = int(result.get("development_selection", {}).get("ensemble_pso", {}).get("seed", SWARM_SEEDS[0]))
+ selected = next((item for item in candidates if int(item.get("seed", -1)) == selected_seed), candidates[0])
+ weights = np.asarray(selected.get("weights", uniform), dtype=np.float64)
+ mixed = np.einsum("m,mnk->nk", weights, test_pool_array)
+ path = workload_root / "test-predictions-ensemble-pso.pt"
+ _save_torch(path, {"probabilities": mixed, "targets": test_labels.cpu(), "weights": weights, "seed": selected.get("seed")})
+ confirmation["ensemble"][method] = {"metrics": _probability_metrics(mixed, test_labels_np), "weights": weights.tolist(), "seed": selected.get("seed"), "prediction_artifact": str(path.relative_to(self.run_root))}
+ result["confirmation"] = confirmation
+ result["leakage_counters"]["official_test_construction"] = 1
+ result["leakage_counters"]["official_test_evaluations"] = test_forward_passes
+ prediction_files = [str(path.relative_to(self.run_root)) for path in workload_root.glob("test-predictions-*.pt")]
+ result["artifact_hashes"].update(fingerprint_paths(self.run_root, prediction_files))
+ self._write_result(result)
+ finish_confirmation(state, success=True)
+ persist_state(self.run_root, state)
+ return result
+
+ def run_phase(self, phase: str) -> dict[str, Any]:
+ if phase == "prepare":
+ return self.run_prepare()
+ if phase == "smoke":
+ return self.run_smoke()
+ if phase == "develop":
+ return self.run_develop()
+ if phase == "confirm":
+ return self.run_confirm()
+ if phase == "publish":
+ return json.loads(self._result_path().read_text(encoding="utf-8"))
+ raise ProtocolError(f"unsupported ResNet phase: {phase}")
+
+
+def create_adapter(*, workload_id: str, config: StudyConfig | Mapping[str, Any], run_root: str | os.PathLike[str], data_root: str | os.PathLike[str], device: str | torch.device = "cpu", allow_download: bool = False, **_: Any) -> ResNetConvergenceAdapter:
+ return ResNetConvergenceAdapter(workload_id=workload_id, config=config, run_root=run_root, data_root=data_root, device=device, allow_download=allow_download)
+
+
+__all__ = [
+ "BATCH_SIZE", "BASE_SEEDS", "CIFARSubset", "CachedSuffixEvaluator", "ResNetCache", "ResNetConvergenceAdapter", "SMOKE_EPOCHS", "TestSealError", "audit_test_duplicates", "build_cifar_manifests", "cached_avgpool_parity", "cached_full_parity", "cached_residual_parity", "classification_metrics", "create_adapter", "evaluate_fitted_ensemble", "evaluate_logits", "head_parameter_names", "load_official_test_data", "make_cifar_resnet", "prepare_cifar_data", "run_ensemble_methods", "run_feature_adam", "run_head_adam", "selected_parameter_names", "train_baseline",
+]
diff --git a/test/post_training_yolo_convergence.py b/test/post_training_yolo_convergence.py
new file mode 100644
index 0000000..33289b6
--- /dev/null
+++ b/test/post_training_yolo_convergence.py
@@ -0,0 +1,2409 @@
+"""Pinned Ultralytics YOLO11n/VOC adapter for the convergence protocol.
+
+The module deliberately keeps Ultralytics, torchvision and ensemble-boxes imports
+inside the operations that need them. Importing this module is consequently safe
+in the normal (non-detection) installation. All persistent writes go through the
+common protocol's atomic helpers and every phase is guarded by the run state.
+"""
+from __future__ import annotations
+
+import copy
+import csv
+import dataclasses
+import hashlib
+import json
+import math
+import os
+import random
+import shutil
+import time
+import warnings
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Any, Callable, Iterable, Iterator, Mapping, Sequence
+
+import numpy as np
+import torch
+from torch import nn
+from pso.optimizer import _RandomSource
+from pso.plugins import ConstrictionMovement, IterationContext, SwarmState
+
+from test.post_training_model_convergence import (
+ BASE_SEEDS,
+ PROJECTION_SEED,
+ PSO_GENERATIONS,
+ PARTICLE_COUNT,
+ RESIDUAL_DIMENSION,
+ RESIDUAL_BOUND,
+ SWARM_SEEDS,
+ AuditResult,
+ ObjectiveResult,
+ PROTOCOL_VERSION,
+ ProtocolError,
+ ResourceCounters,
+ SealError,
+ SelectedResidualCodec,
+ StudyConfig,
+ StudyState,
+ StudyStateMachine,
+ atomic_write_bytes,
+ atomic_write_json,
+ begin_confirmation,
+ canonical_json,
+ fingerprint_file,
+ fingerprint_module,
+ fingerprint_nonselected_state,
+ finish_confirmation,
+ freeze_run,
+ load_frozen_manifest,
+ load_state,
+ prepare_run,
+ run_equal_budget_random,
+ run_residual_pso,
+ run_state_neutral_audit,
+ select_endpoint,
+ sha256_bytes,
+ verify_frozen_manifest,
+)
+
+WORKLOAD_ID = "voc_yolo11n"
+FAMILY = "detection"
+ULTRALYTICS_VERSION = "8.4.142"
+ENSEMBLE_BOXES_VERSION = "1.0.9"
+VOC_CLASSES = (
+ "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car",
+ "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike",
+ "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor",
+)
+VOC_CLASS_TO_ID = {name: index for index, name in enumerate(VOC_CLASSES)}
+BP_COUNT, REFINE_COUNT, SELECTION_COUNT, OBJECTIVE_COUNT = 11551, 2500, 2500, 512
+IMG_SIZE = 640
+EXPECTED_BLOCK_INDEX = 22
+EXPECTED_DETECT_INDEX = 23
+EXPECTED_HEAD_BIAS_COUNT = 252
+VOC_YEARS = ("2007", "2012")
+
+WBF_PARTICLE_COUNT = 12
+WBF_GENERATIONS = 20
+
+class YoloProtocolError(ProtocolError):
+ """A detection-specific protocol violation."""
+
+
+@dataclasses.dataclass(frozen=True)
+class VOCRecord:
+ year: str
+ image_id: str
+ image_path: str
+ annotation_path: str
+ width: int
+ height: int
+ labels: tuple[tuple[int, float, float, float, float], ...]
+ difficult_excluded: int
+ fingerprint: str
+
+ def to_dict(self) -> dict[str, Any]:
+ return dataclasses.asdict(self)
+
+
+@dataclasses.dataclass(frozen=True)
+class VOCManifest:
+ bp_train: tuple[VOCRecord, ...]
+ refine_search: tuple[VOCRecord, ...]
+ selection_val: tuple[VOCRecord, ...]
+ permutation_seed: int
+ duplicate_groups: Mapping[str, tuple[str, ...]]
+ counts: Mapping[str, int]
+ objective_keys: tuple[tuple[str, str], ...]
+
+ def to_dict(self) -> dict[str, Any]:
+ return {
+ "bp_train": [r.to_dict() for r in self.bp_train],
+ "refine_search": [r.to_dict() for r in self.refine_search],
+ "selection_val": [r.to_dict() for r in self.selection_val],
+ "permutation_seed": self.permutation_seed,
+ "duplicate_groups": {k: list(v) for k, v in self.duplicate_groups.items()},
+ "counts": dict(self.counts),
+ "objective_keys": [list(x) for x in self.objective_keys],
+ }
+
+
+@dataclasses.dataclass(frozen=True)
+class VOCTestGuard:
+ run_root: str
+ frozen_manifest_hash: str
+ confirmation_started: bool
+
+ def require_open(self) -> None:
+ if not self.confirmation_started or not self.frozen_manifest_hash:
+ raise SealError("VOC2007 test is sealed until frozen confirmation begins")
+
+
+def _ultralytics() -> Any:
+ """Import the pinned optional package only when a detection operation runs."""
+ try:
+ import ultralytics # type: ignore
+ except ImportError as exc:
+ raise YoloProtocolError(
+ "Ultralytics is required for voc_yolo11n; install ultralytics==8.4.142"
+ ) from exc
+ version = str(getattr(ultralytics, "__version__", ""))
+ if version != ULTRALYTICS_VERSION:
+ raise YoloProtocolError(
+ f"Ultralytics version mismatch: expected {ULTRALYTICS_VERSION}, got {version or 'unknown'}"
+ )
+ return ultralytics
+
+
+def _torchvision_voc() -> Any:
+ try:
+ from torchvision.datasets import VOCDetection # type: ignore
+ except ImportError as exc:
+ raise YoloProtocolError("torchvision with VOCDetection is required for VOC preparation") from exc
+ return VOCDetection
+
+
+def _wbf() -> Callable[..., Any]:
+ try:
+ from ensemble_boxes import weighted_boxes_fusion # type: ignore
+ except ImportError as exc:
+ raise YoloProtocolError(
+ "ensemble-boxes is required for YOLO ensemble arms; install ensemble-boxes==1.0.9"
+ ) from exc
+ module = __import__("ensemble_boxes")
+ version = str(getattr(module, "__version__", ""))
+ if version and version != ENSEMBLE_BOXES_VERSION:
+ raise YoloProtocolError(
+ f"ensemble-boxes version mismatch: expected {ENSEMBLE_BOXES_VERSION}, got {version}"
+ )
+ return weighted_boxes_fusion
+
+
+def pinned_preflight() -> dict[str, str]:
+ """Check optional package pins without importing them at module import time."""
+ ultra = _ultralytics()
+ # Importing ensemble-boxes here verifies the package before a run starts.
+ _wbf()
+ return {
+ "ultralytics": str(getattr(ultra, "__version__", "")),
+ "ensemble_boxes": ENSEMBLE_BOXES_VERSION,
+ "voc_classes": str(len(VOC_CLASSES)),
+ }
+
+
+def _canonical_pixels(image: Any) -> tuple[int, int, bytes]:
+ """Return the label-free duplicate key required by the protocol."""
+ try:
+ from PIL import Image
+ if not isinstance(image, Image.Image):
+ image = Image.open(image)
+ rgb = image.convert("RGB")
+ width, height = rgb.size
+ return width, height, np.asarray(rgb, dtype=np.uint8).tobytes(order="C")
+ except ImportError as exc:
+ raise YoloProtocolError("Pillow is required for VOC duplicate fingerprinting") from exc
+
+
+def image_fingerprint(image: Any) -> str:
+ width, height, pixels = _canonical_pixels(image)
+ digest = hashlib.sha256()
+ digest.update(width.to_bytes(8, "little", signed=False))
+ digest.update(height.to_bytes(8, "little", signed=False))
+ digest.update(pixels)
+ return digest.hexdigest()
+
+
+def _parse_int(node: ET.Element, tag: str) -> int:
+ child = node.find(tag)
+ if child is None or child.text is None:
+ raise YoloProtocolError(f"VOC annotation missing {tag}")
+ try:
+ return int(child.text)
+ except ValueError as exc:
+ raise YoloProtocolError(f"invalid integer in VOC annotation {tag}") from exc
+
+
+def parse_voc_xml(annotation_path: str | os.PathLike[str], image_path: str | os.PathLike[str], *, year: str, image_id: str) -> VOCRecord:
+ """Parse one XML and convert non-difficult objects to normalized xywh labels."""
+ path = Path(annotation_path)
+ root = ET.parse(path).getroot()
+ size = root.find("size")
+ if size is None:
+ raise YoloProtocolError(f"VOC annotation has no size: {path}")
+ width, height = _parse_int(size, "width"), _parse_int(size, "height")
+ if width <= 0 or height <= 0:
+ raise YoloProtocolError(f"invalid VOC dimensions in {path}")
+ labels: list[tuple[int, float, float, float, float]] = []
+ excluded = 0
+ for object_node in root.findall("object"):
+ name_node = object_node.find("name")
+ if name_node is None or not name_node.text:
+ raise YoloProtocolError(f"VOC object has no class in {path}")
+ class_name = name_node.text.strip().lower()
+ if class_name not in VOC_CLASS_TO_ID:
+ raise YoloProtocolError(f"unknown VOC class {class_name!r} in {path}")
+ difficult_node = object_node.find("difficult")
+ difficult = difficult_node is not None and (difficult_node.text or "0").strip() == "1"
+ if difficult:
+ excluded += 1
+ continue
+ box = object_node.find("bndbox")
+ if box is None:
+ raise YoloProtocolError(f"VOC object has no bndbox in {path}")
+ xmin, ymin = _parse_int(box, "xmin"), _parse_int(box, "ymin")
+ xmax, ymax = _parse_int(box, "xmax"), _parse_int(box, "ymax")
+ if xmax < xmin or ymax < ymin:
+ raise YoloProtocolError(f"inverted VOC box in {path}")
+ # This is the pinned Ultralytics VOC convention: center uses -1, while
+ # width and height are the XML extent without an additional correction.
+ center_x = ((xmin + xmax) / 2.0 - 1.0) / width
+ center_y = ((ymin + ymax) / 2.0 - 1.0) / height
+ box_width = (xmax - xmin) / width
+ box_height = (ymax - ymin) / height
+ values = (center_x, center_y, box_width, box_height)
+ if not all(math.isfinite(value) for value in values):
+ raise YoloProtocolError(f"non-finite VOC box in {path}")
+ labels.append((VOC_CLASS_TO_ID[class_name], *values))
+ try:
+ fingerprint = image_fingerprint(image_path)
+ except (OSError, ValueError) as exc:
+ raise YoloProtocolError(f"cannot fingerprint VOC image {image_path}") from exc
+ return VOCRecord(year, image_id, str(image_path), str(annotation_path), width, height, tuple(labels), excluded, fingerprint)
+
+
+def write_yolo_label(record: VOCRecord, path: str | os.PathLike[str]) -> Path:
+ lines = ["%d %.10f %.10f %.10f %.10f" % label for label in record.labels]
+ return atomic_write_bytes(path, ("\n".join(lines) + ("\n" if lines else "")).encode("utf-8"))
+
+
+def _voc_roots(data_root: Path, year: str, *, split: str = "trainval") -> tuple[Path, Path, Path]:
+ if split not in {"trainval", "test"}:
+ raise YoloProtocolError(f"unsupported VOC split: {split}")
+ root = data_root / "VOCdevkit" / f"VOC{year}"
+ return root / "JPEGImages", root / "Annotations", root / "ImageSets" / "Main" / f"{split}.txt"
+def _records_from_voc(data_root: Path, *, allow_download: bool) -> list[VOCRecord]:
+ records: list[VOCRecord] = []
+ for year in VOC_YEARS:
+ image_root, annotation_root, split_path = _voc_roots(data_root, year)
+ if not split_path.is_file():
+ if not allow_download:
+ raise YoloProtocolError(f"VOC{year} is unavailable; rerun preparation with --allow-download")
+ VOCDetection = _torchvision_voc()
+ VOCDetection(root=str(data_root), year=year, image_set="trainval", download=True)
+ if not split_path.is_file():
+ raise YoloProtocolError(f"torchvision did not create VOC{year} trainval manifest")
+ ids = [line.strip() for line in split_path.read_text(encoding="utf-8").splitlines() if line.strip()]
+ for image_id in ids:
+ image_path = image_root / f"{image_id}.jpg"
+ annotation_path = annotation_root / f"{image_id}.xml"
+ if not image_path.is_file() or not annotation_path.is_file():
+ raise YoloProtocolError(f"incomplete VOC{year} item: {image_id}")
+ records.append(parse_voc_xml(annotation_path, image_path, year=year, image_id=image_id))
+ return records
+
+
+def _assign_duplicate_groups(records: Sequence[VOCRecord], *, seed: int) -> tuple[list[VOCRecord], dict[str, tuple[str, ...]]]:
+ groups: dict[str, list[VOCRecord]] = {}
+ for record in records:
+ groups.setdefault(record.fingerprint, []).append(record)
+ rng = random.Random(seed)
+ order = list(records)
+ rng.shuffle(order)
+ order_position = {f"{record.year}:{record.image_id}": index for index, record in enumerate(order)}
+ group_map: dict[str, tuple[str, ...]] = {}
+ for fingerprint, members in groups.items():
+ members.sort(key=lambda record: order_position[f"{record.year}:{record.image_id}"])
+ keys = tuple(f"{record.year}:{record.image_id}" for record in members)
+ group_map[fingerprint] = keys
+ grouped_order: list[VOCRecord] = []
+ seen: set[str] = set()
+ for record in order:
+ if record.fingerprint in seen:
+ continue
+ seen.add(record.fingerprint)
+ grouped_order.extend(groups[record.fingerprint])
+ return grouped_order, group_map
+
+
+def make_voc_manifests(records: Sequence[VOCRecord], *, seed: int = 20260908) -> VOCManifest:
+ if len(records) != 16551:
+ raise YoloProtocolError(f"expected 16,551 VOC trainval records, found {len(records)}")
+ ordered, groups = _assign_duplicate_groups(records, seed=seed)
+ by_key = {
+ f"{record.year}:{record.image_id}": record for record in ordered
+ }
+ ordered_groups: list[tuple[VOCRecord, ...]] = []
+ seen_fingerprints: set[str] = set()
+ for record in ordered:
+ if record.fingerprint in seen_fingerprints:
+ continue
+ seen_fingerprints.add(record.fingerprint)
+ ordered_groups.append(
+ tuple(by_key[key] for key in groups[record.fingerprint])
+ )
+
+ def take_groups(
+ available: Sequence[tuple[VOCRecord, ...]],
+ count: int,
+ ) -> tuple[tuple[VOCRecord, ...], list[tuple[VOCRecord, ...]]]:
+ chosen: list[VOCRecord] = []
+ deferred: list[tuple[VOCRecord, ...]] = []
+ for group in available:
+ if len(chosen) + len(group) <= count:
+ chosen.extend(group)
+ else:
+ deferred.append(group)
+ if len(chosen) != count:
+ raise YoloProtocolError(
+ f"duplicate-safe partition cannot satisfy exact size {count}"
+ )
+ return tuple(chosen), deferred
+
+ bp, remaining = take_groups(ordered_groups, BP_COUNT)
+ refine, remaining = take_groups(remaining, REFINE_COUNT)
+ selection = tuple(record for group in remaining for record in group)
+ if len(bp) != BP_COUNT or len(refine) != REFINE_COUNT or len(selection) != SELECTION_COUNT:
+ raise YoloProtocolError("VOC duplicate grouping did not produce exact manifest sizes")
+ all_keys = {f"{r.year}:{r.image_id}" for r in bp + refine + selection}
+ if len(all_keys) != len(bp) + len(refine) + len(selection):
+ raise YoloProtocolError("VOC manifests overlap")
+ for split in (bp, refine, selection):
+ if not set(range(20)).issubset({label[0] for record in split for label in record.labels}):
+ raise YoloProtocolError("VOC manifest does not contain all 20 classes")
+ objective = tuple((r.year, r.image_id) for r in refine[:OBJECTIVE_COUNT])
+ return VOCManifest(bp, refine, selection, seed, groups, {
+ "bp_train": len(bp), "refine_search": len(refine), "selection_val": len(selection),
+ }, objective)
+
+
+def prepare_voc(
+ data_root: str | os.PathLike[str],
+ run_root: str | os.PathLike[str],
+ *,
+ allow_download: bool,
+ seed: int = 20260908,
+) -> VOCManifest:
+ data = Path(data_root)
+ root = Path(run_root) / "workloads" / WORKLOAD_ID
+ root.mkdir(parents=True, exist_ok=True)
+ records = _records_from_voc(data, allow_download=allow_download)
+ manifest = make_voc_manifests(records, seed=seed)
+ atomic_write_json(root / "voc_manifest.json", manifest.to_dict())
+ labels_root = root / "labels"
+ images_root = root / "images"
+ labels_root.mkdir(parents=True, exist_ok=True)
+ for split_name, split in (
+ ("bp_train", manifest.bp_train),
+ ("refine_search", manifest.refine_search),
+ ("selection_val", manifest.selection_val),
+ ):
+ for record in split:
+ write_yolo_label(
+ record,
+ labels_root / split_name / f"{record.year}_{record.image_id}.txt",
+ )
+ destination = images_root / split_name / f"{record.year}_{record.image_id}.jpg"
+ destination.parent.mkdir(parents=True, exist_ok=True)
+ try:
+ destination.symlink_to(Path(record.image_path).resolve())
+ except FileExistsError:
+ if not destination.exists():
+ raise YoloProtocolError(f"stale image link: {destination}")
+ except OSError:
+ shutil.copy2(record.image_path, destination)
+ return manifest
+
+
+def guarded_voc_test_loader(
+ data_root: str | os.PathLike[str],
+ run_root: str | os.PathLike[str],
+ *,
+ confirmation: bool = False,
+) -> Any:
+ """Open VOC2007 test only after a valid frozen manifest and confirmation."""
+ root = Path(run_root)
+ state = load_state(root)
+ if state.state != StudyState.CONFIRMING or not confirmation:
+ raise SealError("VOC2007 official test is sealed until confirm phase")
+ frozen = verify_frozen_manifest(root)
+ image_root, annotation_root, split_path = _voc_roots(Path(data_root), "2007", split="test")
+ if not split_path.is_file():
+ raise YoloProtocolError("VOC2007 test manifest is unavailable")
+ records = []
+ for image_id in (
+ line.strip()
+ for line in split_path.read_text(encoding="utf-8").splitlines()
+ if line.strip()
+ ):
+ image_path = image_root / f"{image_id}.jpg"
+ annotation_path = annotation_root / f"{image_id}.xml"
+ records.append(
+ parse_voc_xml(annotation_path, image_path, year="2007", image_id=image_id)
+ )
+ return records, VOCTestGuard(str(root), frozen.manifest_hash, True)
+
+
+def write_study_yaml(
+ manifest: VOCManifest,
+ path: str | os.PathLike[str],
+ *,
+ labels_root: str | os.PathLike[str],
+) -> Path:
+ """Write a study-only YAML with train/selection images and no test/download."""
+ labels = Path(labels_root).resolve()
+ dataset_root = labels.parent
+ yaml = (
+ f"path: {dataset_root}\n"
+ f"train: {dataset_root / 'images' / 'bp_train'}\n"
+ f"val: {dataset_root / 'images' / 'selection_val'}\n"
+ "names:\n"
+ + "\n".join(f" {i}: {name}" for i, name in enumerate(VOC_CLASSES))
+ + "\n"
+ )
+ if "download:" in yaml or "\ntest:" in yaml:
+ raise YoloProtocolError("study YAML cannot contain download or test entries")
+ if manifest.counts.get("bp_train") != BP_COUNT:
+ raise YoloProtocolError("study YAML manifest is not the pinned bp_train split")
+ return atomic_write_bytes(path, yaml.encode("utf-8"))
+
+
+def _model_yaml_path() -> str:
+ try:
+ import ultralytics
+ except ImportError as exc:
+ raise YoloProtocolError("Ultralytics is required to create YOLO11n") from exc
+ path = Path(ultralytics.__file__).resolve().parent / "cfg" / "models" / "11" / "yolo11.yaml"
+ if not path.is_file():
+ raise YoloProtocolError(f"pinned yolo11.yaml is missing: {path}")
+ return str(path)
+
+
+def make_yolo11n(*, device: str | torch.device = "cpu", nc: int = 20) -> Any:
+ """Create a scratch YOLO11n with a rebuilt 20-class Detect head."""
+ ultra = _ultralytics()
+ if nc != 20:
+ raise YoloProtocolError("VOC YOLO11n must have exactly 20 classes")
+ wrapper = ultra.YOLO(_model_yaml_path(), task="detect")
+ try:
+ from ultralytics.nn.tasks import DetectionModel # type: ignore
+ wrapper.model = DetectionModel(_model_yaml_path(), ch=3, nc=nc, verbose=False)
+ from ultralytics.cfg import get_cfg # type: ignore
+ wrapper.model.args = get_cfg()
+ except (ImportError, TypeError) as exc:
+ raise YoloProtocolError("pinned Ultralytics cannot construct 20-class DetectionModel") from exc
+ wrapper.model.to(device)
+ assert_yolo_topology(wrapper.model)
+ return wrapper
+
+
+def assert_yolo_topology(model: nn.Module) -> None:
+ layers = getattr(model, "model", None)
+ if layers is None or len(layers) <= EXPECTED_DETECT_INDEX:
+ raise YoloProtocolError("YOLO11n graph is shorter than the pinned block22/Detect graph")
+ block = layers[EXPECTED_BLOCK_INDEX]
+ detect = layers[EXPECTED_DETECT_INDEX]
+ if block.__class__.__name__ != "C3k2":
+ raise YoloProtocolError(f"expected model.22 C3k2, found {block.__class__.__name__}")
+ if detect.__class__.__name__ != "Detect":
+ raise YoloProtocolError(f"expected model.23 Detect, found {detect.__class__.__name__}")
+ if int(getattr(detect, "nc", -1)) != 20:
+ raise YoloProtocolError(f"expected Detect.nc=20, found {getattr(detect, 'nc', None)}")
+ if not hasattr(detect, "cv2") or not hasattr(detect, "cv3") or len(detect.cv2) != 3 or len(detect.cv3) != 3:
+ raise YoloProtocolError("pinned Detect head must expose three cv2 and cv3 branches")
+ bias = [*list(detect.cv2[i][-1].bias for i in range(3)), *list(detect.cv3[i][-1].bias for i in range(3))]
+ if any(value is None for value in bias):
+ raise YoloProtocolError("all Detect terminal heads must expose biases")
+ if sum(int(value.numel()) for value in bias) != EXPECTED_HEAD_BIAS_COUNT:
+ raise YoloProtocolError("Detect output bias dimension does not equal pinned 252")
+
+
+def selected_block_names(model: nn.Module) -> tuple[str, ...]:
+ names = tuple(name for name, _ in model.named_parameters() if name.startswith("model.22."))
+ if not names:
+ raise YoloProtocolError("no model.22 floating parameters found")
+ if any(not dict(model.named_parameters())[name].is_floating_point() for name in names):
+ raise YoloProtocolError("model.22 contains a non-floating selected parameter")
+ return names
+
+
+def selected_head_bias_names(model: nn.Module) -> tuple[str, ...]:
+ names = tuple(
+ name
+ for name, _ in model.named_parameters()
+ if len(name.split(".")) == 6
+ and name.split(".")[0:2] == ["model", "23"]
+ and name.split(".")[2] in {"cv2", "cv3"}
+ and name.split(".")[3] in {"0", "1", "2"}
+ and name.split(".")[4:] == ["2", "bias"]
+ )
+ if len(names) != 6 or sum(dict(model.named_parameters())[name].numel() for name in names) != EXPECTED_HEAD_BIAS_COUNT:
+ raise YoloProtocolError("Detect bias selection does not match six tensors and 252 scalars")
+ return names
+
+
+def _detect_inputs(model: nn.Module, images: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+ """Execute the frozen prefix and return the three Detect inputs."""
+ outputs: dict[int, torch.Tensor] = {}
+ x = images
+ layers = model.model
+ for index, module in enumerate(layers[:EXPECTED_DETECT_INDEX]):
+ source = getattr(module, "f", -1)
+ if isinstance(source, int):
+ x = x if source == -1 else outputs[source]
+ else:
+ x = [x if item == -1 else outputs[item] for item in source]
+ x = module(x)
+ outputs[index] = x
+ try:
+ return outputs[16].detach(), outputs[19].detach(), outputs[21].detach()
+ except KeyError as exc:
+ raise YoloProtocolError(
+ "pinned YOLO graph did not produce cached tensors 16,19,21"
+ ) from exc
+
+
+def _letterbox_record(record: VOCRecord, *, size: int = IMG_SIZE) -> tuple[torch.Tensor, tuple[float, tuple[float, float]]]:
+ """Decode one VOC image and apply the pinned fixed 640 letterbox."""
+ try:
+ from PIL import Image
+ except ImportError as exc:
+ raise YoloProtocolError("Pillow is required for VOC image decoding") from exc
+ image = Image.open(record.image_path).convert("RGB")
+ width, height = image.size
+ gain = min(size / width, size / height)
+ resized = image.resize((max(1, round(width * gain)), max(1, round(height * gain))), Image.Resampling.BILINEAR)
+ canvas = Image.new("RGB", (size, size), (114, 114, 114))
+ pad_x = (size - resized.width) / 2
+ pad_y = (size - resized.height) / 2
+ canvas.paste(resized, (round(pad_x), round(pad_y)))
+ value = (
+ torch.from_numpy(np.asarray(canvas, dtype=np.uint8).copy())
+ .permute(2, 0, 1)
+ .float()
+ .div_(255.0)
+ )
+ return value, (gain, (pad_x, pad_y))
+
+def _native_target(
+ record: VOCRecord,
+ *,
+ index: int = 0,
+ ratio_pad: tuple[float, tuple[float, float]],
+ size: int = IMG_SIZE,
+) -> dict[str, torch.Tensor]:
+ gain, (pad_x, pad_y) = ratio_pad
+ transformed = []
+ for label, center_x, center_y, width, height in record.labels:
+ transformed.append(
+ (
+ (
+ center_x * record.width * gain + pad_x
+ ) / size,
+ (
+ center_y * record.height * gain + pad_y
+ ) / size,
+ width * record.width * gain / size,
+ height * record.height * gain / size,
+ )
+ )
+ cls = torch.tensor(
+ [label[0] for label in record.labels],
+ dtype=torch.float32,
+ )
+ boxes = torch.tensor(transformed, dtype=torch.float32)
+ return {
+ "batch_idx": torch.full(
+ (len(record.labels),),
+ index,
+ dtype=torch.int64,
+ ),
+ "cls": cls.reshape(-1, 1),
+ "bboxes": boxes.reshape(-1, 4),
+ }
+
+def native_batch(records: Sequence[VOCRecord], *, device: torch.device | str) -> tuple[torch.Tensor, dict[str, torch.Tensor], tuple[tuple[float, tuple[float, float]], ...]]:
+ images, targets, ratio_pad = [], [], []
+ for index, record in enumerate(records):
+ image, padding = _letterbox_record(record)
+ images.append(image)
+ targets.append(
+ _native_target(record, index=index, ratio_pad=padding)
+ )
+ ratio_pad.append(padding)
+ if not images:
+ raise YoloProtocolError("native batch cannot be empty")
+ batch = {key: torch.cat([target[key] for target in targets], dim=0).to(device) for key in ("batch_idx", "cls", "bboxes")}
+ batch["img"] = torch.stack(images).to(device)
+ return batch["img"], batch, tuple(ratio_pad)
+
+@dataclasses.dataclass
+class DetectionCache:
+ images: torch.Tensor
+ detect_inputs: tuple[torch.Tensor, torch.Tensor, torch.Tensor]
+ targets: tuple[Mapping[str, Any], ...]
+ provenance: Mapping[str, Any]
+
+ def __post_init__(self) -> None:
+ self.images = self.images.detach().clone()
+ self.detect_inputs = tuple(value.detach().clone() for value in self.detect_inputs) # type: ignore[assignment]
+
+ def to(self, device: torch.device | str) -> "DetectionCache":
+ return DetectionCache(self.images.to(device), tuple(value.to(device) for value in self.detect_inputs), self.targets, self.provenance)
+
+
+def build_detection_cache(model: nn.Module, batches: Iterable[tuple[torch.Tensor, Mapping[str, Any]]], *, provenance: Mapping[str, Any], device: torch.device | str) -> DetectionCache:
+ images_out: list[torch.Tensor] = []
+ inputs_out = [[], [], []]
+ targets: list[Mapping[str, Any]] = []
+ model.eval()
+ with torch.no_grad():
+ for images, batch in batches:
+ images = images.to(device=device, dtype=torch.float32)
+ cached = _detect_inputs(model, images)
+ images_out.append(images.cpu())
+ for index, value in enumerate(cached):
+ inputs_out[index].append(value.cpu())
+ targets.append(dict(batch))
+ if not images_out:
+ raise YoloProtocolError("cannot create a cache from zero batches")
+ return DetectionCache(
+ torch.cat(images_out),
+ tuple(torch.cat(values) for values in inputs_out),
+ tuple(targets),
+ dict(provenance),
+ )
+
+
+def _loss_callable(model: nn.Module) -> Any:
+ try:
+ from ultralytics.utils.loss import v8DetectionLoss # type: ignore
+ except ImportError as exc:
+ raise YoloProtocolError(
+ "pinned v8DetectionLoss is unavailable"
+ ) from exc
+ if not hasattr(model, "args") or not hasattr(model, "model"):
+ raise YoloProtocolError(
+ "native detection loss requires an Ultralytics DetectionModel"
+ )
+ return v8DetectionLoss(model)
+
+
+def _loss_value(loss: Any) -> torch.Tensor:
+ value = loss[0] if isinstance(loss, tuple) else loss
+ if not torch.is_tensor(value):
+ value = torch.as_tensor(value)
+ return value.sum()
+
+
+def _merged_cache_batch(cache: DetectionCache, images: torch.Tensor, device: torch.device) -> dict[str, Any]:
+ batch: dict[str, Any] = {}
+ pieces = {key: [] for key in ("batch_idx", "cls", "bboxes")}
+ cursor = 0
+ for target in cache.targets:
+ batch_idx = torch.as_tensor(target.get("batch_idx", torch.empty(0)), device=device)
+ pieces["batch_idx"].append(batch_idx + cursor)
+ for key in ("cls", "bboxes"):
+ if key in target:
+ pieces[key].append(torch.as_tensor(target[key], device=device))
+ image_count = int(target["img"].shape[0]) if torch.is_tensor(target.get("img")) else 1
+ cursor += image_count
+ for key, values in pieces.items():
+ if values:
+ batch[key] = torch.cat(values)
+ batch["img"] = images
+ return batch
+
+
+def cached_detection_loss_tensor(
+ model: nn.Module,
+ cache: DetectionCache,
+ *,
+ model_device: torch.device | str = "cpu",
+ backward: bool = False,
+) -> torch.Tensor:
+ model.eval()
+ device = torch.device(model_device)
+ loss_fn = _loss_callable(model)
+ images = cache.images.to(device)
+ inputs = tuple(value.to(device) for value in cache.detect_inputs)
+ batch = _merged_cache_batch(cache, images, device)
+ with torch.set_grad_enabled(backward):
+ predictions = model.model[EXPECTED_BLOCK_INDEX](inputs[2])
+ outputs = model.model[EXPECTED_DETECT_INDEX](
+ [inputs[0], inputs[1], predictions]
+ )
+ value = _loss_value(loss_fn(outputs, batch))
+ return value / max(int(images.shape[0]), 1)
+
+
+def cached_detection_objective(
+ model: nn.Module,
+ cache: DetectionCache,
+ *,
+ codec: SelectedResidualCodec | None = None,
+ residual: torch.Tensor | None = None,
+ model_device: torch.device | str = "cpu",
+ backward: bool = False,
+) -> ObjectiveResult:
+ """Evaluate cached block22+Detect outputs through native v8DetectionLoss."""
+ if codec is not None and residual is not None:
+ codec.apply_residual(model, residual)
+ value = cached_detection_loss_tensor(
+ model,
+ cache,
+ model_device=model_device,
+ backward=backward,
+ )
+ if backward:
+ value.backward()
+ count = int(cache.images.shape[0])
+ return ObjectiveResult(
+ float(value.detach().cpu()),
+ count,
+ 1,
+ int(backward),
+ )
+
+
+def cached_full_parity(model: nn.Module, cache: DetectionCache, *, model_device: torch.device | str = "cpu", atol: float = 1e-6, rtol: float = 1e-5) -> dict[str, Any]:
+ """Compare full-prefix block22+Detect outputs against cached suffix execution."""
+ device = torch.device(model_device)
+ model.eval()
+ with torch.no_grad():
+ cached_inputs = tuple(value.to(device) for value in cache.detect_inputs)
+ suffix = model.model[EXPECTED_BLOCK_INDEX](cached_inputs[2])
+ cached = model.model[EXPECTED_DETECT_INDEX]([cached_inputs[0], cached_inputs[1], suffix])
+ full_inputs = _detect_inputs(model, cache.images.to(device))
+ full_suffix = model.model[EXPECTED_BLOCK_INDEX](full_inputs[2])
+ full = model.model[EXPECTED_DETECT_INDEX]([full_inputs[0], full_inputs[1], full_suffix])
+ def max_error(left: Any, right: Any) -> float:
+ if torch.is_tensor(left) and torch.is_tensor(right):
+ return float((left - right).abs().max().cpu())
+ if isinstance(left, (tuple, list)) and isinstance(right, (tuple, list)):
+ return max((max_error(a, b) for a, b in zip(left, right)), default=0.0)
+ return 0.0
+ error = max_error(cached, full)
+ reference = cached[0] if isinstance(cached, (tuple, list)) else cached
+ scale = float(reference.detach().abs().max().cpu()) if torch.is_tensor(reference) else 1.0
+ allowed = atol + rtol * max(scale, 1.0)
+ if error > allowed:
+ raise YoloProtocolError(f"cached/full parity failed: max_error={error}, allowed={allowed}")
+ return {"max_abs_error": error, "allowed": allowed, "passed": True}
+
+
+def native_detection_metrics(predictions: Sequence[Mapping[str, Any]], targets: Sequence[Mapping[str, Any]], *, iou_thresholds: Sequence[float] = tuple(np.arange(0.5, 0.96, 0.05))) -> dict[str, Any]:
+ """Compute dataset-level detection metrics from native boxes, not image means."""
+ if len(predictions) != len(targets):
+ raise YoloProtocolError("prediction/target image counts differ")
+ # The pinned validator is the authority for production metrics. This helper
+ # is intentionally strict about shape and delegates matching when available.
+ try:
+ from ultralytics.utils.metrics import ap_per_class # type: ignore
+ except ImportError as exc:
+ raise YoloProtocolError("pinned Ultralytics metric implementation unavailable") from exc
+ stats: list[tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]] = []
+ for prediction, target in zip(predictions, targets):
+ stats.append((
+ np.asarray(prediction.get("correct", []), dtype=bool),
+ np.asarray(prediction.get("conf", []), dtype=np.float32),
+ np.asarray(prediction.get("pred_cls", []), dtype=np.float32),
+ np.asarray(target.get("target_cls", []), dtype=np.float32),
+ ))
+ if not stats:
+ return {"map50": 0.0, "map50_95": 0.0, "precision": 0.0, "recall": 0.0, "per_class_ap": []}
+ correct, conf, pred_cls, target_cls = (np.concatenate(parts) if any(parts) else np.empty((0,)) for parts in zip(*stats))
+ if correct.ndim == 1:
+ correct = correct[:, None]
+ if correct.size == 0:
+ return {"map50": 0.0, "map50_95": 0.0, "precision": 0.0, "recall": 0.0, "per_class_ap": [0.0] * 20}
+ result = ap_per_class(correct, conf, pred_cls, target_cls, plot=False, names={i: n for i, n in enumerate(VOC_CLASSES)})
+ # Ultralytics has changed tuple ordering across versions; pinned 8.4.142 is
+ # checked here rather than silently publishing an incorrectly labelled metric.
+ if len(result) < 4:
+ raise YoloProtocolError("unexpected pinned ap_per_class return shape")
+ tp, fp, p, r, f1, ap, unique = result[:7]
+ ap = np.asarray(ap)
+ if ap.ndim == 2:
+ per_class = ap.mean(axis=1)
+ map50 = float(ap[:, 0].mean()) if ap.shape[1] else 0.0
+ map5095 = float(ap.mean())
+ else:
+ per_class, map50, map5095 = ap, float(ap.mean()), float(ap.mean())
+ return {"map50": map50, "map50_95": map5095, "precision": float(np.asarray(p).mean()), "recall": float(np.asarray(r).mean()), "per_class_ap": per_class.tolist()}
+
+
+def transform_boxes_to_original(boxes: np.ndarray, *, ratio_pad: tuple[float, tuple[float, float]], shape: tuple[int, int]) -> np.ndarray:
+ values = np.asarray(boxes, dtype=np.float64).copy()
+ if values.ndim != 2 or values.shape[1] < 4:
+ raise YoloProtocolError("boxes must have shape (N,4+) in letterbox pixels")
+ gain, pad = float(ratio_pad[0]), ratio_pad[1]
+ if gain <= 0:
+ raise YoloProtocolError("letterbox gain must be positive")
+ values[:, [0, 2]] = (values[:, [0, 2]] - float(pad[0])) / gain
+ values[:, [1, 3]] = (values[:, [1, 3]] - float(pad[1])) / gain
+ height, width = shape
+ values[:, [0, 2]] = np.clip(values[:, [0, 2]], 0, width)
+ values[:, [1, 3]] = np.clip(values[:, [1, 3]], 0, height)
+ return values
+
+
+def transform_boxes_to_letterbox(boxes: np.ndarray, *, ratio_pad: tuple[float, tuple[float, float]]) -> np.ndarray:
+ values = np.asarray(boxes, dtype=np.float64).copy()
+ gain, pad = float(ratio_pad[0]), ratio_pad[1]
+ if gain <= 0:
+ raise YoloProtocolError("letterbox gain must be positive")
+ values[:, [0, 2]] = values[:, [0, 2]] * gain + float(pad[0])
+ values[:, [1, 3]] = values[:, [1, 3]] * gain + float(pad[1])
+ return values
+
+
+def weighted_box_fusion(images: Sequence[Mapping[str, Any]], weights: Sequence[float]) -> Mapping[str, np.ndarray]:
+ if len(images) != len(weights) or not images:
+ raise YoloProtocolError("WBF requires one image prediction per model and one weight per model")
+ normalized_weights = np.asarray(weights, dtype=np.float64)
+ if (
+ not np.isfinite(normalized_weights).all()
+ or (normalized_weights < 0).any()
+ or float(normalized_weights.sum()) <= 0
+ ):
+ raise YoloProtocolError(
+ "WBF weights must be finite, nonnegative, and have positive sum"
+ )
+ normalized_weights /= normalized_weights.sum()
+ fuse = _wbf()
+ boxes_list, scores_list, labels_list = [], [], []
+ for image in images:
+ boxes = np.asarray(image.get("boxes", []), dtype=np.float64)
+ scores = np.asarray(image.get("scores", []), dtype=np.float64)
+ labels = np.asarray(image.get("labels", []), dtype=np.int64)
+ if boxes.size:
+ boxes = boxes.reshape(-1, 4)
+ if (boxes < 0).any() or (boxes > 1).any():
+ raise YoloProtocolError("WBF boxes must be normalized original-coordinate xyxy")
+ boxes_list.append(boxes.tolist())
+ scores_list.append(scores.tolist())
+ labels_list.append(labels.tolist())
+ boxes, scores, labels = fuse(
+ boxes_list, scores_list, labels_list, weights=normalized_weights.tolist(),
+ iou_thr=.55, skip_box_thr=.001, conf_type="avg", allows_overflow=False,
+ )
+ order = np.argsort(-np.asarray(scores))[:300]
+ return {"boxes": np.asarray(boxes)[order], "scores": np.asarray(scores)[order], "labels": np.asarray(labels, dtype=np.int64)[order]}
+
+
+
+def _wbf_dataset_metrics(
+ member_predictions: Sequence[Sequence[Mapping[str, Any]]],
+ targets: Sequence[Mapping[str, Any]],
+ weights: Sequence[float],
+) -> dict[str, Any]:
+ from test.evaluate_post_training_model_convergence import detection_metrics
+
+ records: list[dict[str, Any]] = []
+ for image_index, target in enumerate(targets):
+ fused = weighted_box_fusion(
+ [member_predictions[member][image_index] for member in range(3)],
+ weights,
+ )
+ predictions = [
+ {
+ "box": [float(value) for value in box],
+ "class_id": int(label),
+ "score": float(score),
+ }
+ for box, score, label in zip(
+ fused["boxes"], fused["scores"], fused["labels"]
+ )
+ ]
+ boxes = np.asarray(target.get("boxes", []), dtype=np.float64).reshape(-1, 4)
+ labels = np.asarray(target.get("labels", []), dtype=np.int64)
+ ground_truth = [
+ {
+ "box": [float(value) for value in box],
+ "class_id": int(label),
+ }
+ for box, label in zip(boxes, labels)
+ ]
+ records.append(
+ {
+ "image_id": str(target.get("image_id", image_index)),
+ "predictions": predictions,
+ "ground_truth": ground_truth,
+ }
+ )
+ return detection_metrics(records, class_count=len(VOC_CLASSES))
+
+
+def run_wbf_weight_search(
+ member_predictions: Sequence[Sequence[Mapping[str, Any]]],
+ targets: Sequence[Mapping[str, Any]],
+ *,
+ seed: int,
+ random_mode: bool,
+) -> dict[str, Any]:
+ if (
+ len(member_predictions) != 3
+ or any(len(rows) != len(targets) for rows in member_predictions)
+ or seed not in SWARM_SEEDS
+ ):
+ raise YoloProtocolError(
+ "WBF search requires three aligned member sets and a fixed swarm seed"
+ )
+ rng = _RandomSource(seed=seed, device="cpu")
+ positions = [torch.zeros(3, dtype=torch.float32)]
+ for _ in range(5):
+ value = rng.uniform((3,), -0.25, 0.25, device="cpu")
+ positions.extend((value, -value))
+ positions.append(rng.uniform((3,), -0.25, 0.25, device="cpu"))
+ velocities = [torch.zeros_like(position) for position in positions]
+ pbest = [position.clone() for position in positions]
+ pbest_scores = [math.inf] * len(positions)
+ best = positions[0].clone()
+ best_score = math.inf
+ best_metrics: dict[str, Any] | None = None
+ trajectory: list[dict[str, Any]] = []
+ movement = ConstrictionMovement(c0=2.05, c1=2.05)
+ evaluations = 0
+
+ for generation in range(1, WBF_GENERATIONS + 1):
+ for index, position in enumerate(positions):
+ weights = torch.softmax(position, dim=0).tolist()
+ metrics = _wbf_dataset_metrics(member_predictions, targets, weights)
+ score = -float(metrics["map50_95"])
+ evaluations += 1
+ if score < pbest_scores[index]:
+ pbest_scores[index] = score
+ pbest[index] = position.clone()
+ if score < best_score:
+ best_score = score
+ best = position.clone()
+ best_metrics = metrics
+ trajectory.append(
+ {
+ "generation": generation,
+ "objective": best_score,
+ "map50_95": -best_score,
+ }
+ )
+ if generation == 20:
+ break
+ if random_mode:
+ positions = [
+ rng.uniform((3,), -5.0, 5.0, device="cpu")
+ for _ in positions
+ ]
+ velocities = [torch.zeros_like(position) for position in positions]
+ continue
+ state = SwarmState(
+ positions=tuple(position.clone() for position in positions),
+ velocities=tuple(velocity.clone() for velocity in velocities),
+ pbest_positions=tuple(position.clone() for position in pbest),
+ pbest_scores=tuple((score, 0.0, 0.0) for score in pbest_scores),
+ gbest_position=best.clone(),
+ gbest_score=(best_score, 0.0, 0.0),
+ pbest_improved=tuple(False for _ in positions),
+ )
+ next_positions: list[torch.Tensor] = []
+ next_velocities: list[torch.Tensor] = []
+ for index, position in enumerate(positions):
+ context = IterationContext(
+ epoch=generation + 1,
+ total_epochs=20,
+ w=1.0,
+ particle_idx=index,
+ is_negative=False,
+ rng=rng,
+ optimizer=None,
+ )
+ _, velocity = movement.propose(index, state, context)
+ candidate = position + velocity
+ outside = (candidate < -5.0) | (candidate > 5.0)
+ next_positions.append(torch.clamp(candidate, -5.0, 5.0))
+ next_velocities.append(
+ torch.where(outside, torch.zeros_like(velocity), velocity)
+ )
+ positions, velocities = next_positions, next_velocities
+ if (
+ best_metrics is None
+ or evaluations != WBF_PARTICLE_COUNT * WBF_GENERATIONS
+ ):
+ raise YoloProtocolError("WBF search did not complete exactly 240 evaluations")
+ return {
+ "seed": seed,
+ "method": "ensemble_random" if random_mode else "ensemble_pso",
+ "queries": evaluations,
+ "sample_evaluations": evaluations * len(targets),
+ "logits": best.tolist(),
+ "weights": torch.softmax(best, dim=0).tolist(),
+ "metrics": best_metrics,
+ "trajectory": trajectory,
+ }
+class StrictScratchTrainer:
+ """Native training boundary: OOM, NaN and invalid checkpoints are fatal."""
+ def __init__(
+ self,
+ *,
+ device: str,
+ batch: int = 16,
+ epochs: int = 100,
+ ) -> None:
+ if device not in {"cpu", "mps"}:
+ raise YoloProtocolError(
+ "device must remain cpu or mps for the complete run"
+ )
+ if epochs not in {2, 100}:
+ raise YoloProtocolError("trainer epochs must be smoke 2 or production 100")
+ self.device, self.batch, self.epochs = device, batch, epochs
+ self.ema_capture: dict[str, torch.Tensor] | None = None
+ self.telemetry: list[dict[str, Any]] = []
+
+ @property
+ def overrides(self) -> dict[str, Any]:
+ return {
+ "epochs": self.epochs, "optimizer": "SGD", "lr0": .01, "lrf": .01,
+ "momentum": .937, "weight_decay": .0005, "cos_lr": True,
+ "warmup_epochs": 3, "batch": self.batch, "imgsz": IMG_SIZE,
+ "amp": False, "workers": 0, "deterministic": True, "patience": 0,
+ "pretrained": False, "close_mosaic": 10, "device": self.device,
+ "val": True, "plots": False, "save": True,
+ }
+
+ def capture_live_ema(self, trainer: Any, epoch: int) -> None:
+ metrics = getattr(trainer, "metrics", None)
+ if self.epochs == 2 or epoch >= self.epochs - 11:
+ row = {"epoch": epoch + 1}
+ if isinstance(metrics, Mapping):
+ row.update(
+ {
+ str(key): float(value)
+ for key, value in metrics.items()
+ if isinstance(value, (int, float))
+ }
+ )
+ self.telemetry.append(row)
+ if epoch != self.epochs - 1:
+ return
+ ema = getattr(getattr(trainer, "ema", None), "ema", None)
+ if ema is None:
+ raise YoloProtocolError("live fp32 EMA is unavailable at final epoch")
+ self.ema_capture = {name: value.detach().float().cpu().clone() for name, value in ema.state_dict().items()}
+ if not all(bool(torch.isfinite(value).all()) for value in self.ema_capture.values()):
+ raise YoloProtocolError("live EMA contains non-finite values")
+
+ def refusal(self, error: BaseException) -> None:
+ message = str(error).lower()
+ if "out of memory" in message or "nan" in message or "checkpoint" in message:
+ raise YoloProtocolError(f"native training failed without recovery: {error}") from error
+ raise error
+
+
+def _reused_native_baseline(
+ run_path: Path,
+ trainer: StrictScratchTrainer,
+ base_seed: int,
+) -> dict[str, Any] | None:
+ baseline_root = (
+ run_path
+ / "workloads"
+ / WORKLOAD_ID
+ / "baselines"
+ / str(base_seed)
+ )
+ marker_path = baseline_root / "baseline_reuse.json"
+ if not marker_path.is_file():
+ return None
+ marker = json.loads(marker_path.read_text(encoding="utf-8"))
+ output = baseline_root / "ema_fp32.pt"
+ results_path = (
+ run_path
+ / "ultralytics"
+ / f"base-{base_seed}-{trainer.epochs}e"
+ / "results.csv"
+ )
+ if (
+ marker.get("protocol_version") != PROTOCOL_VERSION
+ or marker.get("checkpoint_hash") != fingerprint_file(output)
+ or marker.get("results_hash") != fingerprint_file(results_path)
+ ):
+ raise YoloProtocolError(
+ f"invalid reused baseline marker: {marker_path}"
+ )
+ with results_path.open(newline="", encoding="utf-8") as stream:
+ rows = list(csv.DictReader(stream))
+ if (
+ len(rows) != trainer.epochs
+ or int(float(rows[-1]["epoch"])) != trainer.epochs
+ ):
+ raise YoloProtocolError(
+ "reused native baseline does not contain every epoch"
+ )
+ state = torch.load(output, map_location="cpu", weights_only=True)
+ if not isinstance(state, Mapping) or not state or not all(
+ torch.is_tensor(value)
+ and bool(torch.isfinite(value).all())
+ for value in state.values()
+ ):
+ raise YoloProtocolError(
+ "reused native baseline checkpoint is invalid"
+ )
+ telemetry = [
+ {
+ key.strip(): float(value)
+ for key, value in row.items()
+ if key is not None
+ and value is not None
+ and value.strip()
+ }
+ for row in rows[-11:]
+ ]
+ return {
+ "seed": base_seed,
+ "checkpoint": str(output.relative_to(run_path)),
+ "telemetry": telemetry,
+ "resolved": trainer.overrides,
+ "checkpoint_hash": fingerprint_file(output),
+ "result": f"reused:{marker['source_run']}",
+ "reused": True,
+ }
+
+
+def train_baseline(
+ *,
+ model: Any,
+ yaml_path: str,
+ trainer: StrictScratchTrainer,
+ run_root: str | os.PathLike[str],
+ base_seed: int,
+) -> dict[str, Any]:
+ """Run one native baseline, or reuse an explicitly hash-verified run."""
+ _ultralytics()
+ if not isinstance(base_seed, int) or base_seed not in BASE_SEEDS:
+ raise YoloProtocolError("base seed must be one of 501, 502, 503")
+ run_path = Path(run_root)
+ os.environ["YOLO_CONFIG_DIR"] = str(run_path / "yolo_config")
+ os.environ["ULTRALYTICS_HUB"] = "0"
+ os.environ["ULTRALYTICS_SETTINGS_YAML"] = str(run_path / "ultralytics_settings.yaml")
+ reused = _reused_native_baseline(
+ run_path,
+ trainer,
+ base_seed,
+ )
+ if reused is not None:
+ return reused
+ random.seed(base_seed)
+ np.random.seed(base_seed)
+ torch.manual_seed(base_seed)
+ callback = lambda tr: trainer.capture_live_ema(tr, int(getattr(tr, "epoch", -1)))
+ add_callback = getattr(model, "add_callback", None)
+ if not callable(add_callback):
+ raise YoloProtocolError("Ultralytics model does not expose add_callback")
+ add_callback("on_train_epoch_end", callback)
+ try:
+ results = model.train(
+ data=yaml_path,
+ seed=base_seed,
+ project=str(run_path.resolve() / "ultralytics"),
+ name=f"base-{base_seed}-{trainer.epochs}e",
+ exist_ok=False,
+ **trainer.overrides,
+ )
+ except BaseException as exc:
+ trainer.refusal(exc)
+ if trainer.ema_capture is None:
+ raise YoloProtocolError("training did not capture final live fp32 EMA")
+ output = (
+ run_path
+ / "workloads"
+ / WORKLOAD_ID
+ / "baselines"
+ / str(base_seed)
+ / "ema_fp32.pt"
+ )
+ atomic_write_bytes(
+ output,
+ _torch_save_bytes(trainer.ema_capture),
+ )
+ return {
+ "seed": base_seed,
+ "checkpoint": str(output.relative_to(run_path)),
+ "checkpoint_hash": fingerprint_file(output),
+ "telemetry": trainer.telemetry,
+ "resolved": trainer.overrides,
+ "result": str(results),
+ }
+
+
+def _resolve_run_path(
+ run_root: str | os.PathLike[str],
+ value: str | os.PathLike[str],
+) -> Path:
+ path = Path(value)
+ if path.is_absolute():
+ return path
+ return Path(run_root) / path
+
+def _checkpoint_record_valid(
+ run_root: str | os.PathLike[str],
+ record: Any,
+) -> bool:
+ if not isinstance(record, Mapping):
+ return False
+ checkpoint = record.get("checkpoint")
+ expected = record.get("checkpoint_hash")
+ if not isinstance(checkpoint, str) or not isinstance(expected, str):
+ return False
+ path = _resolve_run_path(run_root, checkpoint)
+ return path.is_file() and fingerprint_file(path) == expected
+
+
+def _torch_save_bytes(value: Any) -> bytes:
+ import io
+ stream = io.BytesIO(); torch.save(value, stream); return stream.getvalue()
+
+
+def _manifest_from_json(path: str | os.PathLike[str]) -> VOCManifest:
+ value = json.loads(Path(path).read_text(encoding="utf-8"))
+ def records(key: str) -> tuple[VOCRecord, ...]:
+ rows = []
+ for row in value[key]:
+ item = dict(row)
+ item["labels"] = tuple(tuple(label) for label in item["labels"])
+ rows.append(VOCRecord(**item))
+ return tuple(rows)
+ return VOCManifest(
+ records("bp_train"), records("refine_search"), records("selection_val"),
+ int(value["permutation_seed"]),
+ {str(k): tuple(v) for k, v in value["duplicate_groups"].items()},
+ {str(k): int(v) for k, v in value["counts"].items()},
+ tuple(tuple(item) for item in value["objective_keys"]),
+ )
+
+
+def _native_loss_tensor(detector: nn.Module, images: torch.Tensor, batch: Mapping[str, Any]) -> torch.Tensor:
+ detector.train()
+ prediction = detector(images)
+ loss = detector.loss(dict(batch), prediction) if callable(getattr(detector, "loss", None)) else _loss_callable(detector)(prediction, dict(batch))
+ return _loss_value(loss) / max(int(images.shape[0]), 1)
+
+
+def _accumulated_native_loss(detector: nn.Module, batches: Sequence[tuple[torch.Tensor, Mapping[str, Any]]]) -> torch.Tensor:
+ if not batches:
+ raise YoloProtocolError("native objective requires at least one batch")
+ total: torch.Tensor | None = None
+ count = 0
+ for images, batch in batches:
+ value = _native_loss_tensor(detector, images, batch)
+ weight = int(images.shape[0])
+ total = value * weight if total is None else total + value * weight
+ count += weight
+ if total is None or count == 0:
+ raise YoloProtocolError("native objective contains zero images")
+ return total / count
+
+
+def _native_predictions(detector: nn.Module, images: torch.Tensor) -> list[Any]:
+ from ultralytics.utils.nms import non_max_suppression # type: ignore
+ detector.eval()
+ with torch.no_grad():
+ raw = detector(images)
+ return non_max_suppression(raw, conf_thres=.001, iou_thres=.7, max_det=300, multi_label=True, agnostic=False)
+
+
+
+
+def evaluate_detection_records(
+ detector: nn.Module,
+ records: Sequence[VOCRecord],
+ *,
+ device: torch.device | str,
+ batch_size: int = 4,
+) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+ from test.evaluate_post_training_model_convergence import detection_metrics
+
+ rows: list[dict[str, Any]] = []
+ for start in range(0, len(records), batch_size):
+ subset = records[start : start + batch_size]
+ images, _, ratio_pad = native_batch(subset, device=device)
+ outputs = _native_predictions(detector, images)
+ for record, output, padding in zip(subset, outputs, ratio_pad):
+ boxes = (
+ output[:, :4].detach().cpu().numpy()
+ if output.numel()
+ else np.empty((0, 4))
+ )
+ boxes = transform_boxes_to_original(
+ boxes,
+ ratio_pad=padding,
+ shape=(record.height, record.width),
+ )
+ predictions = [
+ {
+ "box": [float(value) for value in box],
+ "class_id": int(label),
+ "score": float(score),
+ }
+ for box, score, label in zip(
+ boxes,
+ output[:, 4].detach().cpu().numpy()
+ if output.numel()
+ else np.empty((0,)),
+ output[:, 5].detach().cpu().numpy()
+ if output.numel()
+ else np.empty((0,)),
+ )
+ ]
+ ground_truth = []
+ for label in record.labels:
+ _, cx, cy, width, height = label
+ ground_truth.append(
+ {
+ "box": [
+ float((cx - width / 2) * record.width),
+ float((cy - height / 2) * record.height),
+ float((cx + width / 2) * record.width),
+ float((cy + height / 2) * record.height),
+ ],
+ "class_id": int(label[0]),
+ }
+ )
+ rows.append(
+ {
+ "image_id": f"{record.year}:{record.image_id}",
+ "predictions": predictions,
+ "ground_truth": ground_truth,
+ }
+ )
+ return detection_metrics(rows, class_count=len(VOC_CLASSES)), rows
+
+def run_smoke_feature_pso(detector: nn.Module, cache: DetectionCache, *, device: torch.device | str) -> dict[str, Any]:
+ """Run the real two-generation smoke PSO over cached native loss."""
+ codec = SelectedResidualCodec(detector, selected_block_names(detector), projection_seed=PROJECTION_SEED)
+ generator = torch.Generator(device="cpu").manual_seed(601)
+ positions = [torch.zeros(RESIDUAL_DIMENSION, device=device)]
+ for _ in range(11):
+ positions.append(torch.rand(RESIDUAL_DIMENSION, generator=generator).to(device).mul_(.5).sub_(.25))
+ velocities = [torch.zeros_like(position) for position in positions]
+ pbest = [position.clone() for position in positions]
+ scores: list[float | None] = [None] * len(positions)
+ gbest: torch.Tensor | None = None
+ gscore = math.inf
+ trajectory = []
+ for generation in range(1, 3):
+ for index, position in enumerate(positions):
+ result = cached_detection_objective(detector, cache, codec=codec, residual=position, model_device=device)
+ if scores[index] is None or result.loss < scores[index]:
+ scores[index] = result.loss
+ pbest[index] = position.clone()
+ if result.loss < gscore:
+ gscore, gbest = result.loss, position.clone()
+ if gbest is None:
+ raise YoloProtocolError("smoke PSO did not produce an incumbent")
+ trajectory.append({"generation": generation, "objective_best": gscore})
+ if generation == 2:
+ break
+ for index in range(len(positions)):
+ r1 = torch.rand(RESIDUAL_DIMENSION, generator=generator).to(device)
+ r2 = torch.rand(RESIDUAL_DIMENSION, generator=generator).to(device)
+ velocity = .7 * velocities[index] + 1.49445 * r1 * (pbest[index] - positions[index]) + 1.49445 * r2 * (gbest - positions[index])
+ proposal = torch.clamp(positions[index] + velocity, -1.0, 1.0)
+ velocities[index] = torch.where((proposal == -1.0) | (proposal == 1.0), torch.zeros_like(velocity), velocity)
+ positions[index] = proposal
+ return {"generations": 2, "queries": 24, "best_objective": gscore, "trajectory": trajectory}
+def run_feature_search(
+ model: nn.Module,
+ objective: Callable[[torch.Tensor], ObjectiveResult | float],
+ *,
+ base_seed: int,
+ swarm_seed: int,
+ device: torch.device | str,
+ validation: Callable[[torch.Tensor], AuditResult] | None = None,
+) -> dict[str, Any]:
+ """Run fixed feature PSO and equal-query random arms for one base."""
+ names = selected_block_names(model)
+ codec = SelectedResidualCodec(
+ model,
+ names,
+ projection_seed=PROJECTION_SEED,
+ )
+ if base_seed not in BASE_SEEDS or swarm_seed not in SWARM_SEEDS:
+ raise YoloProtocolError(
+ "feature arms require the fixed base and swarm seed sets"
+ )
+ pso = run_residual_pso(
+ objective,
+ codec,
+ seed=swarm_seed,
+ device=device,
+ model=model,
+ validation=validation,
+ objective_samples=OBJECTIVE_COUNT,
+ )
+ random_result = run_equal_budget_random(
+ objective,
+ codec,
+ seed=swarm_seed,
+ device=device,
+ model=model,
+ validation=validation,
+ objective_samples=OBJECTIVE_COUNT,
+ )
+ return {
+ "base_seed": base_seed,
+ "swarm_seed": swarm_seed,
+ "selected_names": list(names),
+ "projection_seed": PROJECTION_SEED,
+ "feature_pso": pso.to_dict(include_vectors=True),
+ "feature_random": random_result.to_dict(include_vectors=True),
+ }
+
+
+def run_bounded_adam(
+ model: nn.Module,
+ parameters: Sequence[str],
+ objective: Callable[[], torch.Tensor],
+ *,
+ updates: int = 40,
+ lr: float = 1e-3,
+ bounds: float | Mapping[str, float] = 0.25,
+) -> dict[str, Any]:
+ """Run the fixed 40-step full-objective AdamW arm from the base state."""
+ if updates != 40 or lr != 1e-3:
+ raise YoloProtocolError("AdamW arm requires exactly 40 updates at lr=1e-3")
+ named = dict(model.named_parameters())
+ selected = [named[name] for name in parameters if name in named]
+ if len(selected) != len(parameters):
+ raise YoloProtocolError("AdamW arm includes an unknown parameter")
+ base = {name: value.detach().clone() for name, value in zip(parameters, selected)}
+ optimizer = torch.optim.AdamW(selected, lr=lr, betas=(.9, .999), eps=1e-8, weight_decay=0.0)
+ trajectory: list[dict[str, float]] = []
+ try:
+ for update in range(updates + 1):
+ value = objective()
+ if not torch.is_tensor(value) or value.ndim != 0 or not bool(torch.isfinite(value).item()):
+ raise YoloProtocolError("AdamW objective must return one finite scalar tensor")
+ trajectory.append({"update": update, "objective": float(value.detach().cpu())})
+ if update == updates:
+ break
+ optimizer.zero_grad(set_to_none=True)
+ value.backward()
+ optimizer.step()
+ with torch.no_grad():
+ for name, parameter in zip(parameters, selected):
+ limit = float(bounds[name] if isinstance(bounds, Mapping) else bounds)
+ parameter.copy_(torch.clamp(parameter, base[name] - limit, base[name] + limit))
+ finally:
+ optimizer.zero_grad(set_to_none=True)
+ return {
+ "method": "feature_adam" if any(name.startswith("model.22.") for name in parameters) else "head_adam",
+ "parameters": list(parameters),
+ "updates": updates,
+ "trajectory": trajectory,
+ "final_objective": trajectory[-1]["objective"],
+ }
+
+
+def run_head_adam(
+ model: nn.Module,
+ objective: Callable[[], torch.Tensor],
+) -> dict[str, Any]:
+ """Run the six Detect-terminal-bias control with its declared ±0.25 box."""
+ return run_bounded_adam(
+ model,
+ selected_head_bias_names(model),
+ objective,
+ bounds=0.25,
+ )
+
+
+class YoloConvergenceAdapter:
+ def __init__(self, *, workload_id: str, config: StudyConfig, run_root: str | os.PathLike[str], data_root: str | os.PathLike[str], device: str | torch.device, allow_download: bool) -> None:
+ if workload_id != WORKLOAD_ID:
+ raise YoloProtocolError(f"unsupported workload id: {workload_id}")
+ if str(device) not in {"cpu", "mps"}:
+ raise YoloProtocolError("device must be cpu or mps")
+ self.workload_id, self.config = workload_id, config
+ self.run_root, self.data_root, self.device = Path(run_root), Path(data_root), str(device)
+ self.allow_download = bool(allow_download)
+ self.root = self.run_root / "workloads" / WORKLOAD_ID
+ self.result_path = self.root / "result.json"
+ self.result: dict[str, Any] = {"workload_id": WORKLOAD_ID, "family": FAMILY, "config": config.to_dict(), "manifests": {}, "provenance": {}, "baselines": {}, "arms": {}, "ensemble": {}, "development_selection": {}, "confirmation": {}, "integrity": {}, "leakage_counters": {"official_test_data_loaded_before_freeze": False, "official_test_evaluations_before_freeze": 0, "official_test_construction": 0, "official_test_forward_passes": 0}, "resource_ledger": {}, "artifact_hashes": {}}
+ if self.result_path.is_file():
+ persisted = json.loads(self.result_path.read_text(encoding="utf-8"))
+ if persisted.get("workload_id") != WORKLOAD_ID:
+ raise YoloProtocolError("persisted workload id mismatch")
+ if StudyConfig.from_dict(persisted.get("config", {})) != config:
+ raise YoloProtocolError("persisted configuration mismatch")
+ self.result = persisted
+
+ def _save(self) -> None:
+ self.root.mkdir(parents=True, exist_ok=True)
+ atomic_write_json(self.result_path, self.result)
+
+ def prepare(self) -> dict[str, Any]:
+ if not (self.run_root / "state.json").is_file():
+ prepare_run(self.run_root, self.config)
+ package = pinned_preflight()
+ manifest = prepare_voc(self.data_root, self.run_root, allow_download=self.allow_download, seed=self.config.split_seed)
+ yaml_path = write_study_yaml(manifest, self.root / "study.yaml", labels_root=self.root / "labels")
+ self.result["manifests"] = {"voc": str(self.root / "voc_manifest.json"), "study_yaml": str(yaml_path), "counts": dict(manifest.counts), "objective_count": len(manifest.objective_keys)}
+ self.result["provenance"] = {"packages": package, "projection_seed": PROJECTION_SEED, "data_root": str(self.data_root)}
+ self.result["integrity"] = {"prepared": True, "classes": list(VOC_CLASSES), "test_sealed": True, "official_test_opened": False}
+ self._save()
+ return self.result
+
+ def smoke(self) -> dict[str, Any]:
+ if not (self.root / "voc_manifest.json").is_file():
+ self.prepare()
+ pinned_preflight()
+ manifest = _manifest_from_json(self.root / "voc_manifest.json")
+ smoke_train = manifest.bp_train[:32]
+ smoke_val = manifest.selection_val[:16]
+ train_list = self.root / "smoke_train.txt"
+ val_list = self.root / "smoke_val.txt"
+ atomic_write_bytes(
+ train_list,
+ (
+ "\n".join(
+ str(
+ (
+ self.root
+ / "images"
+ / "bp_train"
+ / f"{record.year}_{record.image_id}.jpg"
+ ).absolute()
+ )
+ for record in smoke_train
+ )
+ + "\n"
+ ).encode("utf-8"),
+ )
+ atomic_write_bytes(
+ val_list,
+ (
+ "\n".join(
+ str(
+ (
+ self.root
+ / "images"
+ / "selection_val"
+ / f"{record.year}_{record.image_id}.jpg"
+ ).absolute()
+ )
+ for record in smoke_val
+ )
+ + "\n"
+ ).encode("utf-8"),
+ )
+ smoke_yaml = self.root / "smoke.yaml"
+ atomic_write_bytes(
+ smoke_yaml,
+ (
+ f"path: {self.root.resolve()}\n"
+ f"train: {train_list.resolve()}\n"
+ f"val: {val_list.resolve()}\n"
+ "names:\n"
+ + "\n".join(
+ f" {index}: {name}"
+ for index, name in enumerate(VOC_CLASSES)
+ )
+ + "\n"
+ ).encode("utf-8"),
+ )
+ smoke_wrapper = make_yolo11n(device=self.device)
+ smoke_training = train_baseline(
+ model=smoke_wrapper,
+ yaml_path=str(smoke_yaml),
+ trainer=StrictScratchTrainer(
+ device=self.device,
+ batch=4,
+ epochs=2,
+ ),
+ run_root=self.run_root,
+ base_seed=BASE_SEEDS[0],
+ )
+ images, batch, _ = native_batch(
+ manifest.refine_search[:2],
+ device=self.device,
+ )
+ detector = make_yolo11n(device=self.device).model
+ detector.load_state_dict(
+ torch.load(
+ _resolve_run_path(
+ self.run_root,
+ smoke_training["checkpoint"],
+ ),
+ map_location=self.device,
+ weights_only=True,
+ ),
+ strict=True,
+ )
+ detector.train()
+ loss = _native_loss_tensor(detector, images, batch)
+ if not bool(torch.isfinite(loss).item()):
+ raise YoloProtocolError("smoke native detection loss is non-finite")
+ detector.zero_grad(set_to_none=True)
+ loss.backward()
+ detector.zero_grad(set_to_none=True)
+ detector.eval()
+ predictions = _native_predictions(detector, images)
+ cache = build_detection_cache(detector, [(images, batch)], provenance={"phase": "smoke"}, device=self.device)
+ parity_zero = cached_full_parity(detector, cache, model_device=self.device)
+ names = selected_block_names(detector)
+ codec = SelectedResidualCodec(detector, names, projection_seed=PROJECTION_SEED)
+ zero = codec.zero_residual(device=self.device)
+ zero_loss = cached_detection_objective(detector, cache, codec=codec, residual=zero, model_device=self.device)
+ smoke_pso = run_smoke_feature_pso(detector, cache, device=self.device)
+ nonzero = torch.full((RESIDUAL_DIMENSION,), .1, device=self.device)
+ nonzero_loss = cached_detection_objective(detector, cache, codec=codec, residual=nonzero, model_device=self.device)
+ nonzero_parity = cached_full_parity(detector, cache, model_device=self.device)
+ codec.restore_base(detector)
+ if not math.isfinite(nonzero_loss.loss):
+ raise YoloProtocolError("smoke cached native loss is non-finite")
+ checkpoint = self.root / "smoke_checkpoint.pt"
+ atomic_write_bytes(checkpoint, _torch_save_bytes(detector.state_dict()))
+ reloaded = make_yolo11n(device=self.device).model
+ reloaded.load_state_dict(torch.load(checkpoint, map_location=self.device, weights_only=True), strict=True)
+ self.result["integrity"].update({
+ "smoke": True,
+ "selected_block_names": list(names),
+ "selected_head_bias_names": list(selected_head_bias_names(detector)),
+ "topology": "model.22 C3k2 -> model.23 Detect",
+ "smoke_native_loss": zero_loss.to_dict(),
+ "smoke_nonzero_loss": nonzero_loss.to_dict(),
+ "smoke_cached_full_parity": parity_zero,
+ "smoke_nonzero_full_parity": nonzero_parity,
+ "smoke_pso": smoke_pso,
+ "smoke_training": {
+ "epochs": 2,
+ "batch": 4,
+ "telemetry": smoke_training["telemetry"],
+ "checkpoint": str(checkpoint.relative_to(self.run_root)),
+ },
+ "smoke_nms_images": len(predictions),
+ "smoke_checkpoint": str(checkpoint),
+ })
+ self._save()
+ return self.result
+
+ def develop(self) -> dict[str, Any]:
+ if not (self.root / "voc_manifest.json").is_file():
+ self.prepare()
+ pinned_preflight()
+ manifest = _manifest_from_json(self.root / "voc_manifest.json")
+ yaml_path = self.root / "study.yaml"
+ if not yaml_path.is_file():
+ write_study_yaml(manifest, yaml_path, labels_root=self.root / "labels")
+ objective_records = manifest.refine_search[:OBJECTIVE_COUNT]
+ objective_batches = []
+ for start in range(0, len(objective_records), 8):
+ subset = objective_records[start:start + 8]
+ images, batch, _ = native_batch(subset, device=self.device)
+ objective_batches.append((images, batch))
+ selection_records = manifest.selection_val
+ baselines: dict[str, Any] = dict(
+ self.result.get("baselines", {})
+ )
+ for base_seed in BASE_SEEDS:
+ model = make_yolo11n(device=self.device)
+ trainer = StrictScratchTrainer(device=self.device, batch=16)
+ baseline = baselines.get(str(base_seed))
+ if not _checkpoint_record_valid(self.run_root, baseline):
+ baseline = train_baseline(
+ model=model,
+ yaml_path=str(yaml_path),
+ trainer=trainer,
+ run_root=self.run_root,
+ base_seed=base_seed,
+ )
+ baselines[str(base_seed)] = baseline
+ self.result["baselines"] = baselines
+ self._save()
+ detector = model.model
+ state = torch.load(
+ _resolve_run_path(
+ self.run_root,
+ baseline["checkpoint"],
+ ),
+ map_location=self.device,
+ weights_only=True,
+ )
+ detector.load_state_dict(state, strict=True)
+ detector.to(self.device)
+ detector.eval()
+ cache = build_detection_cache(
+ detector, objective_batches,
+ provenance={"base_seed": base_seed, "split": "refine_search", "count": OBJECTIVE_COUNT},
+ device=self.device,
+ )
+ objective = lambda residual, detector=detector, cache=cache: cached_detection_objective(detector, cache, codec=None, residual=None, model_device=self.device)
+ pristine_state = {
+ name: value.detach().cpu().clone()
+ for name, value in detector.state_dict().items()
+ }
+ self.result["arms"].setdefault("feature_pso", {}).setdefault(
+ str(base_seed), {}
+ )
+ self.result["arms"].setdefault("feature_random", {}).setdefault(
+ str(base_seed), {}
+ )
+ arm_record: dict[str, Any] = {}
+ for swarm_seed in SWARM_SEEDS:
+ existing = [
+ self.result["arms"][method][str(base_seed)].get(
+ str(swarm_seed)
+ )
+ for method in ("feature_pso", "feature_random")
+ ]
+ if all(
+ _checkpoint_record_valid(self.run_root, record)
+ for record in existing
+ ):
+ for method, record in zip(
+ ("feature_pso", "feature_random"),
+ existing,
+ ):
+ arm_record[f"{method}:{swarm_seed}"] = record
+ continue
+ codec = SelectedResidualCodec(
+ detector,
+ selected_block_names(detector),
+ projection_seed=PROJECTION_SEED,
+ )
+ arm_objective = (
+ lambda residual, detector=detector, cache=cache:
+ cached_detection_objective(
+ detector,
+ cache,
+ codec=None,
+ residual=None,
+ model_device=self.device,
+ )
+ )
+ def selection_audit(
+ residual: torch.Tensor,
+ detector: nn.Module = detector,
+ codec: SelectedResidualCodec = codec,
+ ) -> AuditResult:
+ with codec.applied(detector, residual):
+ metrics, _ = evaluate_detection_records(
+ detector,
+ selection_records,
+ device=self.device,
+ )
+ return AuditResult(
+ loss=-float(metrics["map50_95"]),
+ primary_metric=float(metrics["map50_95"]),
+ samples=len(selection_records),
+ metadata=metrics,
+ )
+
+ combined = run_feature_search(
+ detector,
+ arm_objective,
+ base_seed=base_seed,
+ swarm_seed=swarm_seed,
+ device=self.device,
+ validation=selection_audit,
+ )
+ for method in ("feature_pso", "feature_random"):
+ record = dict(combined[method])
+ record.update(
+ {
+ "base_seed": base_seed,
+ "swarm_seed": swarm_seed,
+ "projection_seed": PROJECTION_SEED,
+ }
+ )
+ endpoint_by_generation = {
+ int(endpoint["generation"]): endpoint["residual"]
+ for endpoint in record.get("endpoints", [])
+ }
+ ranked_checkpoints: list[
+ tuple[float, int, list[float], Mapping[str, Any]]
+ ] = []
+ trajectory = record.get("trajectory", [])
+ if trajectory:
+ initial = trajectory[0].get("initial_validation")
+ if isinstance(initial, Mapping):
+ ranked_checkpoints.append(
+ (
+ float(initial["loss"]),
+ 0,
+ [0.0] * RESIDUAL_DIMENSION,
+ initial,
+ )
+ )
+ for row in trajectory:
+ audit = row.get("validation")
+ generation = int(row.get("generation", -1))
+ if isinstance(audit, Mapping):
+ ranked_checkpoints.append(
+ (
+ float(audit["loss"]),
+ generation,
+ list(endpoint_by_generation[generation]),
+ audit,
+ )
+ )
+ if not ranked_checkpoints:
+ raise YoloProtocolError(
+ "feature arm has no selection checkpoints"
+ )
+ ranked_checkpoints.sort(key=lambda item: item[:2])
+ _, selected_generation, selected_residual, selected_audit = (
+ ranked_checkpoints[0]
+ )
+ selection_metrics = dict(
+ selected_audit.get("metadata", {})
+ )
+ candidate_model = make_yolo11n(device=self.device).model
+ candidate_model.load_state_dict(pristine_state, strict=True)
+ candidate_codec = SelectedResidualCodec(
+ candidate_model,
+ selected_block_names(candidate_model),
+ projection_seed=PROJECTION_SEED,
+ )
+ residual = torch.as_tensor(
+ selected_residual,
+ dtype=torch.float32,
+ device=self.device,
+ )
+ candidate_codec.apply_residual(candidate_model, residual)
+ checkpoint = (
+ self.root
+ / "arms"
+ / str(base_seed)
+ / f"{method}-{swarm_seed}.pt"
+ )
+ atomic_write_bytes(
+ checkpoint,
+ _torch_save_bytes(candidate_model.state_dict()),
+ )
+ record["selection_metrics"] = selection_metrics
+ record["selected_generation"] = selected_generation
+ record["selected_residual"] = residual.detach().cpu().tolist()
+ record["checkpoint"] = str(
+ checkpoint.relative_to(self.run_root)
+ )
+ record["checkpoint_hash"] = fingerprint_file(checkpoint)
+ self.result["arms"][method][str(base_seed)][
+ str(swarm_seed)
+ ] = record
+ arm_record[f"{method}:{swarm_seed}"] = record
+ self._save()
+ feature_detector = make_yolo11n(device=self.device).model
+ feature_detector.load_state_dict(pristine_state, strict=True)
+ head_detector = make_yolo11n(device=self.device).model
+ head_detector.load_state_dict(pristine_state, strict=True)
+ feature_names = selected_block_names(feature_detector)
+ feature_codec = SelectedResidualCodec(
+ feature_detector,
+ feature_names,
+ projection_seed=PROJECTION_SEED,
+ )
+ feature_bounds = {
+ name: RESIDUAL_BOUND * scale
+ for name, scale in zip(
+ feature_codec.names,
+ feature_codec.scales,
+ )
+ }
+ feature_adam = run_bounded_adam(
+ feature_detector,
+ feature_names,
+ lambda detector=feature_detector, cache=cache:
+ cached_detection_loss_tensor(
+ detector,
+ cache,
+ model_device=self.device,
+ backward=True,
+ ),
+ bounds=feature_bounds,
+ )
+ head_adam = run_head_adam(
+ head_detector,
+ lambda detector=head_detector, cache=cache:
+ cached_detection_loss_tensor(
+ detector,
+ cache,
+ model_device=self.device,
+ backward=True,
+ ),
+ )
+ for method, control_model, record in (
+ ("feature_adam", feature_detector, feature_adam),
+ ("head_adam", head_detector, head_adam),
+ ):
+ selection_metrics, _ = evaluate_detection_records(
+ control_model,
+ selection_records,
+ device=self.device,
+ )
+ checkpoint = (
+ self.root / "arms" / str(base_seed) / f"{method}.pt"
+ )
+ atomic_write_bytes(
+ checkpoint,
+ _torch_save_bytes(control_model.state_dict()),
+ )
+ record.update(
+ {
+ "base_seed": base_seed,
+ "selection_metrics": selection_metrics,
+ "checkpoint": str(checkpoint.relative_to(self.run_root)),
+ "checkpoint_hash": fingerprint_file(checkpoint),
+ }
+ )
+ self.result["arms"].setdefault(method, {})[
+ str(base_seed)
+ ] = record
+ arm_record[method] = record
+ selected: dict[str, Any] = {}
+ for method in ("feature_pso", "feature_random"):
+ records = self.result["arms"][method][str(base_seed)]
+ winner = max(
+ records.values(),
+ key=lambda record: (
+ float(record["selection_metrics"]["map50_95"]),
+ -int(record["swarm_seed"]),
+ ),
+ )
+ selected[method] = {
+ "swarm_seed": int(winner["swarm_seed"]),
+ "selection_map50_95": float(
+ winner["selection_metrics"]["map50_95"]
+ ),
+ "best_residual": list(winner["selected_residual"]),
+ "generation": int(winner["selected_generation"]),
+ "checkpoint": winner["checkpoint"],
+ "checkpoint_hash": winner["checkpoint_hash"],
+ }
+ self.result["development_selection"][str(base_seed)] = selected
+ arm_path = self.root / "arms" / str(base_seed) / "record.json"
+ atomic_write_json(arm_path, arm_record)
+ pool_records = objective_records + selection_records
+ member_rows = [[] for _ in pool_records]
+ for baseline in baselines.values():
+ detector = make_yolo11n(device=self.device).model
+ detector.load_state_dict(
+ torch.load(
+ _resolve_run_path(
+ self.run_root,
+ baseline["checkpoint"],
+ ),
+ map_location=self.device,
+ weights_only=True,
+ ),
+ strict=True,
+ )
+ detector.eval()
+ for start in range(0, len(pool_records), 4):
+ subset = pool_records[start : start + 4]
+ images, _, ratio_pad = native_batch(
+ subset,
+ device=self.device,
+ )
+ outputs = _native_predictions(detector, images)
+ for offset, (record, output, padding) in enumerate(
+ zip(subset, outputs, ratio_pad)
+ ):
+ boxes = (
+ output[:, :4].detach().cpu().numpy()
+ if output.numel()
+ else np.empty((0, 4))
+ )
+ boxes = transform_boxes_to_original(
+ boxes,
+ ratio_pad=padding,
+ shape=(record.height, record.width),
+ )
+ boxes[:, [0, 2]] /= record.width
+ boxes[:, [1, 3]] /= record.height
+ member_rows[start + offset].append(
+ {
+ "boxes": boxes,
+ "scores": (
+ output[:, 4].detach().cpu().numpy()
+ if output.numel()
+ else np.empty((0,))
+ ),
+ "labels": (
+ output[:, 5]
+ .detach()
+ .cpu()
+ .numpy()
+ .astype(np.int64)
+ if output.numel()
+ else np.empty((0,), dtype=np.int64)
+ ),
+ }
+ )
+ member_predictions = [
+ [member_rows[index][member] for index in range(len(pool_records))]
+ for member in range(len(baselines))
+ ]
+ target_rows = [
+ {
+ "image_id": f"{record.year}:{record.image_id}",
+ "labels": [int(label[0]) for label in record.labels],
+ "boxes": [
+ [
+ float(label[1] - label[3] / 2),
+ float(label[2] - label[4] / 2),
+ float(label[1] + label[3] / 2),
+ float(label[2] + label[4] / 2),
+ ]
+ for label in record.labels
+ ],
+ }
+ for record in pool_records
+ ]
+ objective_members = [
+ rows[:OBJECTIVE_COUNT] for rows in member_predictions
+ ]
+ selection_members = [
+ rows[OBJECTIVE_COUNT:] for rows in member_predictions
+ ]
+ objective_targets = target_rows[:OBJECTIVE_COUNT]
+ selection_targets = target_rows[OBJECTIVE_COUNT:]
+ uniform_weights = [1.0 / len(baselines)] * len(baselines)
+ uniform_objective = _wbf_dataset_metrics(
+ objective_members, objective_targets, uniform_weights
+ )
+ uniform_selection = _wbf_dataset_metrics(
+ selection_members, selection_targets, uniform_weights
+ )
+ ensemble_pso = [
+ run_wbf_weight_search(
+ objective_members,
+ objective_targets,
+ seed=seed,
+ random_mode=False,
+ )
+ for seed in SWARM_SEEDS
+ ]
+ ensemble_random = [
+ run_wbf_weight_search(
+ objective_members,
+ objective_targets,
+ seed=seed,
+ random_mode=True,
+ )
+ for seed in SWARM_SEEDS
+ ]
+ for record in ensemble_pso + ensemble_random:
+ record["selection_metrics"] = _wbf_dataset_metrics(
+ selection_members,
+ selection_targets,
+ record["weights"],
+ )
+ selected_pso = max(
+ ensemble_pso,
+ key=lambda record: (
+ float(record["selection_metrics"]["map50_95"]),
+ -int(record["seed"]),
+ ),
+ )
+ selected_random = max(
+ ensemble_random,
+ key=lambda record: (
+ float(record["selection_metrics"]["map50_95"]),
+ -int(record["seed"]),
+ ),
+ )
+ fused = [
+ weighted_box_fusion(rows, uniform_weights)
+ for rows in member_rows
+ ]
+ ensemble_path = self.root / "ensemble_uniform_wbf.json"
+ atomic_write_json(
+ ensemble_path,
+ [{key: value.tolist() for key, value in row.items()} for row in fused],
+ )
+ self.result["ensemble"] = {
+ "uniform_wbf": {
+ "path": str(ensemble_path.relative_to(self.run_root)),
+ "weights": uniform_weights,
+ "objective_metrics": uniform_objective,
+ "selection_metrics": uniform_selection,
+ },
+ "ensemble_pso": ensemble_pso,
+ "ensemble_random": ensemble_random,
+ }
+ self.result.setdefault("development_selection", {})["ensemble"] = {
+ "ensemble_pso": {
+ "seed": int(selected_pso["seed"]),
+ "weights": list(selected_pso["weights"]),
+ "selection_map50_95": float(
+ selected_pso["selection_metrics"]["map50_95"]
+ ),
+ },
+ "ensemble_random": {
+ "seed": int(selected_random["seed"]),
+ "weights": list(selected_random["weights"]),
+ "selection_map50_95": float(
+ selected_random["selection_metrics"]["map50_95"]
+ ),
+ },
+ }
+ self.result["baselines"] = baselines
+ artifact_paths = [
+ _resolve_run_path(self.run_root, item["checkpoint"])
+ for item in baselines.values()
+ ] + [
+ ensemble_path,
+ self.root / "voc_manifest.json",
+ self.root / "voc_study.yaml",
+ ]
+ artifact_paths.extend(
+ path for path in (self.root / "arms").rglob("*") if path.is_file()
+ )
+ self.result["artifact_hashes"] = {
+ str(path.relative_to(self.run_root)): fingerprint_file(path)
+ for path in artifact_paths
+ if path.is_file()
+ }
+ primary_queries = (
+ len(BASE_SEEDS)
+ * len(SWARM_SEEDS)
+ * PARTICLE_COUNT
+ * PSO_GENERATIONS
+ )
+ ensemble_queries = (
+ len(SWARM_SEEDS)
+ * WBF_PARTICLE_COUNT
+ * WBF_GENERATIONS
+ )
+ self.result["resource_ledger"] = {
+ "baseline_count": len(baselines),
+ "objective_samples": len(objective_records),
+ "selection_samples": len(selection_records),
+ "primary_pso_queries": primary_queries,
+ "primary_random_queries": primary_queries,
+ "ensemble_pso_queries": ensemble_queries,
+ "ensemble_random_queries": ensemble_queries,
+ "pso_candidate_samples": (
+ primary_queries + ensemble_queries
+ ) * len(objective_records),
+ "random_candidate_samples": (
+ primary_queries + ensemble_queries
+ ) * len(objective_records),
+ "pso_cells": len(BASE_SEEDS) * len(SWARM_SEEDS),
+ }
+ self.result["integrity"].update(
+ {"developed": True, "official_test_opened": False}
+ )
+ self._save()
+ return self.result
+ def confirm(self) -> dict[str, Any]:
+ state = load_state(self.run_root)
+ if state.state != StudyState.FROZEN:
+ raise SealError("confirm requires a frozen complete development matrix")
+ begin_confirmation(self.run_root, state)
+ atomic_write_json(self.run_root / "state.json", state.to_dict())
+ records, guard = guarded_voc_test_loader(
+ self.data_root,
+ self.run_root,
+ confirmation=True,
+ )
+ self.result["leakage_counters"]["official_test_construction"] += 1
+ predictions_root = self.root / "confirmation_predictions"
+ predictions_root.mkdir(parents=True, exist_ok=True)
+ confirmation: dict[str, Any] = {
+ "test_records": len(records),
+ "manifest_hash": guard.frozen_manifest_hash,
+ }
+ base_rows: dict[str, list[dict[str, Any]]] = {}
+
+ def evaluate_checkpoint(
+ method: str,
+ base_seed: str,
+ checkpoint: str,
+ ) -> list[dict[str, Any]]:
+ detector = make_yolo11n(device=self.device).model
+ detector.load_state_dict(
+ torch.load(
+ self.run_root / checkpoint
+ if not Path(checkpoint).is_absolute()
+ else checkpoint,
+ map_location=self.device,
+ weights_only=True,
+ ),
+ strict=True,
+ )
+ metrics, rows = evaluate_detection_records(
+ detector,
+ records,
+ device=self.device,
+ )
+ self.result["leakage_counters"][
+ "official_test_forward_passes"
+ ] += 1
+ destination = predictions_root / f"{method}_{base_seed}.json"
+ atomic_write_json(destination, rows)
+ confirmation.setdefault(method, {})[base_seed] = {
+ "predictions": str(destination.relative_to(self.run_root)),
+ "metrics": metrics,
+ "images": len(rows),
+ }
+ return rows
+
+ for base_seed, baseline in sorted(
+ self.result.get("baselines", {}).items()
+ ):
+ base_rows[base_seed] = evaluate_checkpoint(
+ "base",
+ base_seed,
+ baseline["checkpoint"],
+ )
+ selected = self.result["development_selection"][base_seed]
+ for method in ("feature_pso", "feature_random"):
+ swarm_seed = str(selected[method]["swarm_seed"])
+ checkpoint = self.result["arms"][method][base_seed][
+ swarm_seed
+ ]["checkpoint"]
+ evaluate_checkpoint(method, base_seed, checkpoint)
+ for method in ("feature_adam", "head_adam"):
+ checkpoint = self.result["arms"][method][base_seed][
+ "checkpoint"
+ ]
+ evaluate_checkpoint(method, base_seed, checkpoint)
+
+ base_seed_order = [str(seed) for seed in BASE_SEEDS]
+ member_predictions: list[list[dict[str, np.ndarray]]] = []
+ for base_seed in base_seed_order:
+ member: list[dict[str, np.ndarray]] = []
+ for record, row in zip(records, base_rows[base_seed]):
+ boxes = np.asarray(
+ [item["box"] for item in row["predictions"]],
+ dtype=np.float64,
+ ).reshape(-1, 4)
+ if boxes.size:
+ boxes[:, [0, 2]] /= record.width
+ boxes[:, [1, 3]] /= record.height
+ member.append(
+ {
+ "boxes": boxes,
+ "scores": np.asarray(
+ [item["score"] for item in row["predictions"]],
+ dtype=np.float64,
+ ),
+ "labels": np.asarray(
+ [item["class_id"] for item in row["predictions"]],
+ dtype=np.int64,
+ ),
+ }
+ )
+ member_predictions.append(member)
+ target_rows = []
+ for record, row in zip(records, base_rows[base_seed_order[0]]):
+ boxes = np.asarray(
+ [item["box"] for item in row["ground_truth"]],
+ dtype=np.float64,
+ ).reshape(-1, 4)
+ if boxes.size:
+ boxes[:, [0, 2]] /= record.width
+ boxes[:, [1, 3]] /= record.height
+ target_rows.append(
+ {
+ "image_id": row["image_id"],
+ "boxes": boxes.tolist(),
+ "labels": [
+ int(item["class_id"])
+ for item in row["ground_truth"]
+ ],
+ }
+ )
+
+ weights_by_method = {
+ "uniform_wbf": [1.0 / len(BASE_SEEDS)] * len(BASE_SEEDS),
+ "ensemble_pso": self.result["development_selection"]["ensemble"][
+ "ensemble_pso"
+ ]["weights"],
+ "ensemble_random": self.result["development_selection"][
+ "ensemble"
+ ]["ensemble_random"]["weights"],
+ }
+ for method, weights in weights_by_method.items():
+ fused_rows = []
+ for index, record in enumerate(records):
+ fused = weighted_box_fusion(
+ [member[index] for member in member_predictions],
+ weights,
+ )
+ boxes = fused["boxes"].copy()
+ if boxes.size:
+ boxes[:, [0, 2]] *= record.width
+ boxes[:, [1, 3]] *= record.height
+ fused_rows.append(
+ {
+ "image_id": target_rows[index]["image_id"],
+ "predictions": [
+ {
+ "box": [float(value) for value in box],
+ "class_id": int(label),
+ "score": float(score),
+ }
+ for box, label, score in zip(
+ boxes.tolist(),
+ fused["labels"].tolist(),
+ fused["scores"].tolist(),
+ )
+ ],
+ "ground_truth": base_rows[
+ base_seed_order[0]
+ ][index]["ground_truth"],
+ }
+ )
+ destination = predictions_root / f"{method}.json"
+ atomic_write_json(destination, fused_rows)
+ confirmation[method] = {
+ "predictions": str(destination.relative_to(self.run_root)),
+ "metrics": _wbf_dataset_metrics(
+ member_predictions,
+ target_rows,
+ weights,
+ ),
+ "weights": [float(weight) for weight in weights],
+ "images": len(fused_rows),
+ }
+ self.result["confirmation"] = confirmation
+ self.result["artifact_hashes"].update(
+ {
+ str(path.relative_to(self.run_root)): fingerprint_file(path)
+ for path in predictions_root.glob("*.json")
+ }
+ )
+ finish_confirmation(state, success=True)
+ atomic_write_json(self.run_root / "state.json", state.to_dict())
+ self._save()
+ return self.result
+ def run_phase(self, phase: str) -> dict[str, Any]:
+ if phase == "prepare": return self.prepare()
+ if phase == "smoke": return self.smoke()
+ if phase == "develop": return self.develop()
+ if phase == "confirm": return self.confirm()
+ if phase == "publish":
+ if not self.result_path.is_file(): raise SealError("cannot publish without adapter result")
+ return json.loads(self.result_path.read_text(encoding="utf-8"))
+ raise YoloProtocolError(f"unsupported adapter phase: {phase}")
+
+
+def create_adapter(*, workload_id: str = WORKLOAD_ID, config: StudyConfig, run_root: str | os.PathLike[str], data_root: str | os.PathLike[str], device: str | torch.device, allow_download: bool = False) -> YoloConvergenceAdapter:
+ return YoloConvergenceAdapter(workload_id=workload_id, config=config, run_root=run_root, data_root=data_root, device=device, allow_download=allow_download)
+
+
+__all__ = [
+ "BASE_SEEDS", "DetectionCache", "FAMILY", "IMG_SIZE", "OBJECTIVE_COUNT",
+ "PROJECTION_SEED", "StrictScratchTrainer", "ULTRALYTICS_VERSION",
+ "VOC_CLASSES", "VOCManifest", "VOCRecord", "VOCTestGuard", "WORKLOAD_ID",
+ "YoloConvergenceAdapter", "YoloProtocolError", "assert_yolo_topology",
+ "build_detection_cache", "cached_detection_objective", "cached_full_parity",
+ "create_adapter", "guarded_voc_test_loader", "image_fingerprint",
+ "make_voc_manifests", "make_yolo11n", "native_detection_metrics",
+ "parse_voc_xml", "pinned_preflight", "prepare_voc", "run_bounded_adam",
+ "run_feature_search", "run_head_adam", "selected_block_names",
+ "selected_head_bias_names", "train_baseline", "transform_boxes_to_letterbox",
+ "transform_boxes_to_original", "weighted_box_fusion", "write_study_yaml",
+ "write_yolo_label",
+]
diff --git a/test/publish_heavy_cross_split.py b/test/publish_heavy_cross_split.py
new file mode 100644
index 0000000..d89fb10
--- /dev/null
+++ b/test/publish_heavy_cross_split.py
@@ -0,0 +1,655 @@
+"""
+Heavy PSO Cross-Split Experiment Results Publisher.
+
+Protocol Version: HEAVY-PSO-CROSS-SPLIT-PUBLISH 1.0.0
+
+Reads raw candidate and evaluation artifacts from a completed cross-split mission run,
+validates integrity, accounting, test seals, and candidate/evaluation alignment across
+all development variants, and exports deterministic public benchmark artifacts:
+1. benchmark_results/pso_v7_heavy_cross_split.json
+2. benchmark_results/pso_v7_heavy_cross_split.csv
+3. history_plt/pso_v7_heavy_cross_split.png
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import math
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Tuple, Union
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Ensure test directory and repo root are in sys.path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+from benchmark_suite import save_json_atomic
+from pso import __version__ as pso_version
+
+PUBLISH_PROTOCOL_VERSION = "HEAVY-PSO-CROSS-SPLIT-PUBLISH 1.0.0"
+DEFAULT_SOURCE_DIR = Path(".omc/autoresearch/heavy-pso-cross-split-robustness/runs/20260903T162504Z")
+DEFAULT_JSON_OUTPUT = Path("benchmark_results/pso_v7_heavy_cross_split.json")
+DEFAULT_CSV_OUTPUT = Path("benchmark_results/pso_v7_heavy_cross_split.csv")
+DEFAULT_PLOT_OUTPUT = Path("history_plt/pso_v7_heavy_cross_split.png")
+
+WORKLOADS = ["mnist_compact", "mnist_wide", "fashion_compact", "fashion_wide"]
+BASELINE_METHODS = {
+ "mnist_compact": "G8",
+ "mnist_wide": "G5",
+ "fashion_compact": "G8",
+ "fashion_wide": "G5",
+}
+EXPECTED_DEV_SPLITS = [20260905, 20260906]
+EXPECTED_DEV_SWARM_SEEDS = [101, 102, 103]
+EXPECTED_VARIANTS_COUNT = 9
+EXPECTED_VARIANT_IDS = (
+ "iteration-0001-development",
+ "iteration-0002-development",
+ "iteration-0003-replica1-development",
+ "iteration-0003-replica2-development",
+ "iteration-0004-development",
+ "iteration-0005-development",
+ "iteration-0006-development",
+ "iteration-0007-development",
+ "iteration-0008-development",
+)
+EXPECTED_CELLS_PER_VARIANT = 8
+EXPECTED_RUNS_PER_VARIANT = 48
+EXPECTED_QUERIES_PER_VARIANT = 46080
+EXPECTED_SAMPLES_PER_VARIANT = 460800000
+
+EXPECTED_TOTAL_RUNS = EXPECTED_VARIANTS_COUNT * EXPECTED_RUNS_PER_VARIANT # 432
+EXPECTED_TOTAL_QUERIES = EXPECTED_VARIANTS_COUNT * EXPECTED_QUERIES_PER_VARIANT # 414720
+EXPECTED_TOTAL_SAMPLES = EXPECTED_VARIANTS_COUNT * EXPECTED_SAMPLES_PER_VARIANT # 4147200000
+
+
+def discover_and_load_variants(
+ source_dir: Path,
+) -> List[Tuple[Path, Path, Dict[str, Any], Dict[str, Any]]]:
+ """
+ Discovers candidate and evaluation JSON file pairs in source_dir.
+ Supports both subdirectories (candidates/ & evaluations/) and direct directory structure.
+ """
+ if not source_dir.exists():
+ raise FileNotFoundError(f"Source directory does not exist: {source_dir}")
+
+ cand_dir = source_dir / "candidates"
+ eval_dir = source_dir / "evaluations"
+
+ if cand_dir.is_dir() and eval_dir.is_dir():
+ candidate_files = sorted(cand_dir.glob("*.json"))
+ else:
+ candidate_files = sorted(source_dir.glob("*candidate*.json"))
+ if not candidate_files:
+ candidate_files = sorted(source_dir.glob("*.json"))
+
+ if not candidate_files:
+ raise ValueError(f"No candidate JSON files found in {source_dir}")
+
+ observed_ids = tuple(path.stem for path in candidate_files)
+ if observed_ids != EXPECTED_VARIANT_IDS:
+ raise ValueError(
+ f"Expected exact development variants {list(EXPECTED_VARIANT_IDS)}, "
+ f"got {list(observed_ids)}"
+ )
+
+ pairs = []
+ for cf in candidate_files:
+ if cand_dir.is_dir() and eval_dir.is_dir():
+ ef = eval_dir / cf.name
+ else:
+ ef_name = cf.name.replace("candidate", "evaluation")
+ ef = source_dir / ef_name
+ if not ef.exists():
+ ef = cf
+
+ if not ef.exists():
+ raise FileNotFoundError(f"Missing corresponding evaluation file for candidate {cf.name}: {ef}")
+
+ with cf.open("r", encoding="utf-8") as f:
+ cdata = json.load(f)
+ with ef.open("r", encoding="utf-8") as f:
+ edata = json.load(f)
+
+ pairs.append((cf, ef, cdata, edata))
+
+ return pairs
+
+
+def validate_variant_pair(
+ cf_path: Path,
+ ef_path: Path,
+ cdata: Dict[str, Any],
+ edata: Dict[str, Any],
+) -> Dict[str, Any]:
+ """
+ Validates each source candidate/evaluation artifact pair for expected IDs,
+ phase, test seals, no development pass, cell count 8, and resource accounting.
+ """
+ variant_id = cf_path.stem
+
+ # Phase check
+ c_phase = cdata.get("phase")
+ e_phase = edata.get("phase")
+ if c_phase != "development":
+ raise ValueError(f"[{variant_id}] Candidate phase must be 'development', got: {c_phase}")
+ if e_phase not in (None, "development"):
+ raise ValueError(f"[{variant_id}] Evaluation phase must be 'development', got: {e_phase}")
+
+ # Official test sealed check
+ if cdata.get("official_test_data_loaded") is not False:
+ raise ValueError(f"[{variant_id}] candidate.official_test_data_loaded must be False")
+ if cdata.get("official_test_evaluations") != 0:
+ raise ValueError(f"[{variant_id}] candidate.official_test_evaluations must be 0")
+
+ gates = edata.get("gates", {})
+ if gates and "official_test_sealed" in gates:
+ if not gates["official_test_sealed"].get("pass", False):
+ raise ValueError(f"[{variant_id}] evaluation gate 'official_test_sealed' must pass")
+
+ # No development pass check
+ if edata.get("development_pass") is not False:
+ raise ValueError(f"[{variant_id}] development_pass must be False for all variants")
+ if edata.get("pass") is not False:
+ raise ValueError(f"[{variant_id}] pass must be False for all variants")
+ if edata.get("eligible_for_confirmation") is not False:
+ raise ValueError(f"[{variant_id}] eligible_for_confirmation must be False for all variants")
+
+ # Matching cell count 8
+ summary_metrics = edata.get("summary_metrics", {})
+ dev_cells = summary_metrics.get("development_cells")
+ cell_metrics = edata.get("cell_metrics", [])
+ if dev_cells != EXPECTED_CELLS_PER_VARIANT or len(cell_metrics) != EXPECTED_CELLS_PER_VARIANT:
+ raise ValueError(
+ f"[{variant_id}] Expected {EXPECTED_CELLS_PER_VARIANT} development cells, got "
+ f"summary_metrics.development_cells={dev_cells}, len(cell_metrics)={len(cell_metrics)}"
+ )
+
+ # Resource accounting check across per-seed runs
+ splits = cdata.get("splits", {})
+ c_runs = 0
+ c_queries = 0
+ c_samples = 0
+ c_test_evals = 0
+
+ for split_key, split_data in splits.items():
+ for role in ("baselines", "candidates"):
+ for wl_key, wl_data in split_data.get(role, {}).items():
+ for run in wl_data.get("per_seed_runs", []):
+ c_runs += 1
+ c_queries += run.get("total_queries", 0)
+ c_samples += run.get("total_sample_evaluations", 0)
+ c_test_evals += run.get("official_test_evaluations", 0)
+
+ if c_runs != EXPECTED_RUNS_PER_VARIANT:
+ raise ValueError(f"[{variant_id}] Expected {EXPECTED_RUNS_PER_VARIANT} runs, got {c_runs}")
+ if c_queries != EXPECTED_QUERIES_PER_VARIANT:
+ raise ValueError(f"[{variant_id}] Expected {EXPECTED_QUERIES_PER_VARIANT} total queries, got {c_queries}")
+ if c_samples != EXPECTED_SAMPLES_PER_VARIANT:
+ raise ValueError(f"[{variant_id}] Expected {EXPECTED_SAMPLES_PER_VARIANT} total sample evaluations, got {c_samples}")
+ if c_test_evals != 0:
+ raise ValueError(f"[{variant_id}] Official test evaluations must be 0, got {c_test_evals}")
+ resource_totals = cdata.get("resource_totals")
+ if not isinstance(resource_totals, dict):
+ raise ValueError(f"[{variant_id}] candidate.resource_totals must be present")
+ expected_resource_totals = {
+ "total_runs": c_runs,
+ "total_queries": c_queries,
+ "total_samples_evaluated": c_samples,
+ "official_test_evaluations": c_test_evals,
+ }
+ for field, expected in expected_resource_totals.items():
+ if resource_totals.get(field) != expected:
+ raise ValueError(
+ f"[{variant_id}] candidate.resource_totals.{field} must be {expected}, "
+ f"got {resource_totals.get(field)!r}"
+ )
+ wall_time = resource_totals.get("wall_time_sec")
+ if (
+ not isinstance(wall_time, (int, float))
+ or isinstance(wall_time, bool)
+ or not math.isfinite(float(wall_time))
+ or wall_time < 0
+ ):
+ raise ValueError(
+ f"[{variant_id}] candidate.resource_totals.wall_time_sec must be finite and non-negative"
+ )
+
+
+ return {
+ "variant_id": variant_id,
+ "candidate_file": cf_path.name,
+ "evaluation_file": ef_path.name,
+ "candidate_path": _repository_relative_path(cf_path),
+ "evaluation_path": _repository_relative_path(ef_path),
+ "phase": "development",
+ "candidate_config": cdata.get("candidate_config", {}),
+ "score": float(edata.get("score", 0.0)),
+ "pass": False,
+ "development_pass": False,
+ "eligible_for_confirmation": False,
+ "failed_hard_gate_count": edata.get("failed_hard_gate_count", 0),
+ "failed_gates": edata.get("failed_gates", []),
+ "summary_metrics": summary_metrics,
+ "state_ratios": edata.get("state_ratios", {}),
+ "cell_metrics": cell_metrics,
+ "cdata": cdata,
+ "edata": edata,
+ "resources": {
+ "runs": c_runs,
+ "queries": c_queries,
+ "sample_evaluations": c_samples,
+ "wall_time_sec": float(wall_time),
+ "official_test_evaluations": 0,
+ },
+ }
+
+
+def validate_all_variants(
+ variant_summaries: List[Dict[str, Any]],
+) -> Dict[str, Any]:
+ """
+ Validates cumulative resources across all variants, identifies the best-observed variant,
+ and constructs cumulative summary dictionary.
+ """
+ observed_ids = tuple(v["variant_id"] for v in variant_summaries)
+ if observed_ids != EXPECTED_VARIANT_IDS:
+ raise ValueError(
+ f"Expected exact development variants {list(EXPECTED_VARIANT_IDS)}, got {list(observed_ids)}"
+ )
+
+ total_runs = sum(v["resources"]["runs"] for v in variant_summaries)
+ total_queries = sum(v["resources"]["queries"] for v in variant_summaries)
+ total_samples = sum(v["resources"]["sample_evaluations"] for v in variant_summaries)
+ official_test_evals = sum(v["resources"]["official_test_evaluations"] for v in variant_summaries)
+
+ wall_time_sec = round(
+ math.fsum(v["resources"]["wall_time_sec"] for v in variant_summaries),
+ 4,
+ )
+ if total_runs != EXPECTED_TOTAL_RUNS:
+ raise ValueError(f"Cumulative total runs must be {EXPECTED_TOTAL_RUNS}, got {total_runs}")
+ if total_queries != EXPECTED_TOTAL_QUERIES:
+ raise ValueError(f"Cumulative total queries must be {EXPECTED_TOTAL_QUERIES}, got {total_queries}")
+ if total_samples != EXPECTED_TOTAL_SAMPLES:
+ raise ValueError(f"Cumulative total sample evaluations must be {EXPECTED_TOTAL_SAMPLES}, got {total_samples}")
+ if official_test_evals != 0:
+ raise ValueError(f"Cumulative official test evaluations must be 0, got {official_test_evals}")
+
+ # Mark best-observed-but-rejected variant (highest evaluation score)
+ best_variant = max(variant_summaries, key=lambda v: v["score"])
+ for v in variant_summaries:
+ v["is_best_observed"] = (v["variant_id"] == best_variant["variant_id"])
+
+ return {
+ "n_variants": len(variant_summaries),
+ "total_runs": total_runs,
+ "total_queries": total_queries,
+ "total_sample_evaluations": total_samples,
+ "official_test_evaluations": 0,
+ "best_observed_variant_id": best_variant["variant_id"],
+ "wall_time_sec": wall_time_sec,
+ "best_observed_score": best_variant["score"],
+ }
+
+
+def build_publish_json(
+ source_dir: Path,
+ variant_summaries: List[Dict[str, Any]],
+ cum_resources: Dict[str, Any],
+) -> Dict[str, Any]:
+ """
+ Constructs the compact JSON dictionary matching all publication criteria.
+ """
+ now_iso = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+ clean_variants = []
+ for v in sorted(variant_summaries, key=lambda item: item["variant_id"]):
+ clean_variants.append({
+ "variant_id": v["variant_id"],
+ "candidate_file": v["candidate_file"],
+ "evaluation_file": v["evaluation_file"],
+ "phase": v["phase"],
+ "candidate_config": v["candidate_config"],
+ "score": v["score"],
+ "pass": v["pass"],
+ "development_pass": v["development_pass"],
+ "eligible_for_confirmation": v["eligible_for_confirmation"],
+ "failed_hard_gate_count": v["failed_hard_gate_count"],
+ "failed_gates": v["failed_gates"],
+ "is_best_observed": v["is_best_observed"],
+ "summary_metrics": v["summary_metrics"],
+ "state_ratios": v["state_ratios"],
+ "cell_metrics": v["cell_metrics"],
+ "resources": v["resources"],
+ })
+
+ payload = {
+ "protocol_version": PUBLISH_PROTOCOL_VERSION,
+ "pso_version": pso_version,
+ "timestamp": now_iso,
+ "mission_contract": {
+ "phase": "development",
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "confirmation_executed": False,
+ "retained_policy": None,
+ },
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "confirmation_executed": False,
+ "retained_policy": None,
+ "verdict": {
+ "status": "NO_RETAINED_POLICY_NO_CONFIRMATION",
+ "retained_policy": None,
+ "confirmation_executed": False,
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "best_observed_variant_id": cum_resources["best_observed_variant_id"],
+ "best_observed_score": cum_resources["best_observed_score"],
+ "description": (
+ "All 9 development candidates failed the frozen evaluator gates (specifically maximum accuracy "
+ "regression and/or development wide CNN improvement). No candidate qualified for confirmation. "
+ "Confirmation split 20260907 and official test data remained completely unexecuted and sealed."
+ ),
+ },
+ "source_provenance": {
+ "source_dir": _repository_relative_path(source_dir),
+ "n_variants": cum_resources["n_variants"],
+ "candidate_files": [v["candidate_file"] for v in clean_variants],
+ "evaluation_files": [v["evaluation_file"] for v in clean_variants],
+ },
+ "cumulative_resources": cum_resources,
+ "total_runs": cum_resources["total_runs"],
+ "total_wall_time_sec": cum_resources["wall_time_sec"],
+ "total_queries": cum_resources["total_queries"],
+ "total_sample_evaluations": cum_resources["total_sample_evaluations"],
+ "variants": clean_variants,
+ }
+ return payload
+
+
+def build_publish_csv(
+ variant_summaries: List[Dict[str, Any]],
+ csv_path: Path,
+) -> None:
+ """
+ Writes CSV summary with header + exactly 72 data rows (9 variants x 2 splits x 4 workloads).
+ Uses deterministic ordering and atomic writing.
+ """
+ csv_path.parent.mkdir(parents=True, exist_ok=True)
+ fieldnames = [
+ "variant_id",
+ "phase",
+ "split_seed",
+ "workload_id",
+ "baseline_method",
+ "baseline_acc",
+ "candidate_acc",
+ "acc_gain_pp",
+ "baseline_nll",
+ "candidate_nll",
+ "nll_reduction_fraction",
+ "state_ratio",
+ "score",
+ "pass",
+ "is_best_observed",
+ "candidate_path",
+ "evaluation_path",
+ ]
+
+ rows = []
+ # Sort variants deterministically
+ sorted_variants = sorted(variant_summaries, key=lambda v: v["variant_id"])
+
+ for v in sorted_variants:
+ dev_ratios = v.get("state_ratios", {}).get("development", {})
+ cell_metrics = v.get("cell_metrics", [])
+
+ # Sort cells deterministically by split_seed then workload_id order
+ def cell_sort_key(cm):
+ wl_idx = WORKLOADS.index(cm["workload_id"]) if cm["workload_id"] in WORKLOADS else 99
+ return (cm["split_seed"], wl_idx)
+
+ sorted_cells = sorted(cell_metrics, key=cell_sort_key)
+
+ for cm in sorted_cells:
+ workload_id = cm["workload_id"]
+ baseline_method = BASELINE_METHODS.get(workload_id, "G8" if "compact" in workload_id else "G5")
+ st_ratio = dev_ratios.get(workload_id, 0.5) if isinstance(dev_ratios, dict) else 0.5
+
+ row = {
+ "variant_id": v["variant_id"],
+ "phase": cm["phase"],
+ "split_seed": cm["split_seed"],
+ "workload_id": workload_id,
+ "baseline_method": baseline_method,
+ "baseline_acc": cm["baseline_acc"],
+ "candidate_acc": cm["candidate_acc"],
+ "acc_gain_pp": cm["acc_gain_pp"],
+ "baseline_nll": cm["baseline_nll"],
+ "candidate_nll": cm["candidate_nll"],
+ "nll_reduction_fraction": cm["nll_reduction_fraction"],
+ "state_ratio": st_ratio,
+ "score": v["score"],
+ "pass": False,
+ "is_best_observed": v["is_best_observed"],
+ "candidate_path": v["candidate_path"],
+ "evaluation_path": v["evaluation_path"],
+ }
+ rows.append(row)
+
+ tmp_csv = csv_path.with_suffix(".csv.tmp")
+ with tmp_csv.open("w", encoding="utf-8", newline="") as f:
+ writer = csv.DictWriter(f, fieldnames=fieldnames)
+ writer.writeheader()
+ writer.writerows(rows)
+
+ tmp_csv.replace(csv_path)
+
+def _repository_relative_path(path: Path) -> str:
+ try:
+ return str(path.resolve().relative_to(REPO_ROOT.resolve()))
+ except ValueError:
+ return str(path)
+
+
+def render_publish_plot(
+ variant_summaries: List[Dict[str, Any]],
+ plot_path: Path,
+) -> None:
+ """
+ Renders readable 2-panel figure comparing mean gains and worst-cell regressions with frozen thresholds.
+ Clearly marks all variants failed and confirmation withheld.
+ """
+ plot_path.parent.mkdir(parents=True, exist_ok=True)
+
+ sorted_variants = sorted(variant_summaries, key=lambda v: v["variant_id"])
+
+ fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6.5))
+
+ variant_labels = [
+ v["variant_id"].replace("-development", "").replace("iteration-", "iter-")
+ for v in sorted_variants
+ ]
+ x = np.arange(len(variant_labels))
+ width = 0.35
+
+ # Panel 1: Development Grand Mean Performance Gains
+ acc_gains = [v["summary_metrics"].get("development_grand_mean_accuracy_gain_pp", 0.0) for v in sorted_variants]
+ nll_reductions = [v["summary_metrics"].get("development_grand_mean_nll_reduction_fraction", 0.0) * 100.0 for v in sorted_variants]
+
+ ax1.bar(x - width/2, acc_gains, width, label="Grand Mean Acc Gain (pp)", color="#1f77b4")
+ ax1.bar(x + width/2, nll_reductions, width, label="Grand Mean NLL Red. (%)", color="#2ca02c")
+
+ ax1.axhline(0.0, color="black", linestyle="--", linewidth=1.0, alpha=0.7)
+ ax1.set_xticks(x)
+ ax1.set_xticklabels(variant_labels, rotation=35, ha="right", fontsize=9)
+ ax1.set_ylabel("Percentage Points (pp) / Percentage (%)")
+ ax1.set_title("Panel A: Development Grand Mean Performance Gains")
+ ax1.legend(loc="upper left")
+ ax1.grid(True, linestyle="--", alpha=0.4)
+
+ # Panel 2: Worst-Cell Regressions & Wide CNN Improvement vs Gate Thresholds
+ worst_acc_regs = []
+ worst_nll_regs = []
+ mnist_wide_accs = []
+
+ for v in sorted_variants:
+ cell_acc_gains = [cm["acc_gain_pp"] for cm in v["cell_metrics"]]
+ cell_nll_reds = [cm["nll_reduction_fraction"] * 100.0 for cm in v["cell_metrics"]]
+ worst_acc_regs.append(min(cell_acc_gains))
+ worst_nll_regs.append(min(cell_nll_reds))
+ mnist_wide_accs.append(v["summary_metrics"].get("development_mnist_wide_accuracy_gain_pp", 0.0))
+
+ ax2.plot(x, worst_acc_regs, "o-", color="#d62728", linewidth=2, label="Worst-Cell Acc Delta (pp)")
+ ax2.plot(x, worst_nll_regs, "s--", color="#ff7f0e", linewidth=2, label="Worst-Cell NLL Red. (%)")
+ ax2.plot(x, mnist_wide_accs, "^-.", color="#9467bd", linewidth=2, label="MNIST Wide Acc Gain (pp)")
+
+ # Gate threshold lines
+ ax2.axhline(-1.0, color="#d62728", linestyle=":", linewidth=1.5, label="Gate: Max Acc Reg. (-1.0 pp)")
+ ax2.axhline(-5.0, color="#ff7f0e", linestyle=":", linewidth=1.5, label="Gate: Max NLL Reg. (-5.0%)")
+ ax2.axhline(2.0, color="#2ca02c", linestyle="--", linewidth=1.5, label="Gate: MNIST Wide Gain (>= +2 pp)")
+ panel_two_values = worst_acc_regs + worst_nll_regs + mnist_wide_accs + [-5.0, 2.0]
+ panel_two_span = max(panel_two_values) - min(panel_two_values)
+ panel_two_margin = max(1.0, panel_two_span * 0.08)
+ ax2.set_ylim(
+ min(panel_two_values) - panel_two_margin,
+ max(panel_two_values) + panel_two_margin,
+ )
+
+ ax2.set_xticks(x)
+ ax2.set_xticklabels(variant_labels, rotation=35, ha="right", fontsize=9)
+ ax2.set_ylabel("Metrics vs Gate Thresholds")
+ ax2.set_title("Panel B: Worst-Cell Regressions & Wide CNN Improvement vs Gates")
+ ax2.legend(loc="lower left", fontsize=8)
+ ax2.grid(True, linestyle="--", alpha=0.4)
+
+ # Highlight best observed candidate
+ best_idx = next(i for i, v in enumerate(sorted_variants) if v["is_best_observed"])
+ ax1.annotate(
+ f"Best observed, still rejected\nScore: {sorted_variants[best_idx]['score']:.2f}",
+ xy=(best_idx, acc_gains[best_idx]),
+ xycoords="data",
+ xytext=(0.62, 0.94),
+ textcoords="axes fraction",
+ arrowprops=dict(facecolor="black", shrink=0.05, width=1, headwidth=5),
+ bbox=dict(boxstyle="round,pad=0.3", facecolor="white", edgecolor="black", alpha=0.95),
+ fontsize=8,
+ ha="center",
+ va="top",
+ weight="bold",
+ )
+
+ # Mission Outcome Text Banner
+ fig.suptitle(
+ "HEAVY PSO CROSS-SPLIT ROBUSTNESS MISSION REPORT\n"
+ "STATUS: ALL 9 VARIANTS FAILED FROZEN EVALUATOR GATES | CONFIRMATION WITHHELD & SEALED OFFICIAL TEST UNEXECUTED | RETAINED POLICY: NONE",
+ fontsize=11,
+ weight="bold",
+ color="#8b0000",
+ y=0.99,
+ )
+
+ plt.tight_layout(rect=[0, 0, 1, 0.93])
+ tmp_plot = plot_path.with_name(plot_path.stem + "_tmp.png")
+ fig.savefig(tmp_plot, dpi=200, bbox_inches="tight")
+ plt.close(fig)
+ tmp_plot.replace(plot_path)
+
+
+def publish_heavy_cross_split(
+ source_dir: Union[str, Path] = DEFAULT_SOURCE_DIR,
+ output_json: Union[str, Path] = DEFAULT_JSON_OUTPUT,
+ output_csv: Union[str, Path] = DEFAULT_CSV_OUTPUT,
+ output_plot: Union[str, Path] = DEFAULT_PLOT_OUTPUT,
+) -> Dict[str, Any]:
+ """
+ Main programmatic interface for Heavy PSO Cross-Split results publication.
+ Parses artifacts, validates all contracts and resource totals, and writes
+ the compact JSON, CSV summary, and PNG plot atomically.
+ """
+ source_dir = Path(source_dir).resolve()
+ output_json = Path(output_json).resolve()
+ output_csv = Path(output_csv).resolve()
+ output_plot = Path(output_plot).resolve()
+
+ pairs = discover_and_load_variants(source_dir)
+
+ variant_summaries = []
+ for cf, ef, cdata, edata in pairs:
+ summary = validate_variant_pair(cf, ef, cdata, edata)
+ variant_summaries.append(summary)
+
+ cum_resources = validate_all_variants(variant_summaries)
+
+ json_payload = build_publish_json(source_dir, variant_summaries, cum_resources)
+ save_json_atomic(json_payload, output_json)
+
+ build_publish_csv(variant_summaries, output_csv)
+
+ render_publish_plot(variant_summaries, output_plot)
+
+ return json_payload
+
+
+def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(
+ description="Publish Heavy PSO Cross-Split Robustness Mission Results"
+ )
+ parser.add_argument(
+ "--source-dir",
+ type=Path,
+ default=DEFAULT_SOURCE_DIR,
+ help=f"Raw experiment runs directory (default: {DEFAULT_SOURCE_DIR})",
+ )
+ parser.add_argument(
+ "--output-json",
+ type=Path,
+ default=DEFAULT_JSON_OUTPUT,
+ help=f"Output compact JSON path (default: {DEFAULT_JSON_OUTPUT})",
+ )
+ parser.add_argument(
+ "--output-csv",
+ type=Path,
+ default=DEFAULT_CSV_OUTPUT,
+ help=f"Output CSV summary path (default: {DEFAULT_CSV_OUTPUT})",
+ )
+ parser.add_argument(
+ "--output-plot",
+ type=Path,
+ default=DEFAULT_PLOT_OUTPUT,
+ help=f"Output PNG plot path (default: {DEFAULT_PLOT_OUTPUT})",
+ )
+ return parser
+
+
+def main():
+ parser = build_parser()
+ args = parser.parse_args()
+ publish_heavy_cross_split(
+ source_dir=args.source_dir,
+ output_json=args.output_json,
+ output_csv=args.output_csv,
+ output_plot=args.output_plot,
+ )
+ print(f"[{PUBLISH_PROTOCOL_VERSION}] Successfully published cross-split results!")
+ print(f" JSON: {args.output_json}")
+ print(f" CSV: {args.output_csv}")
+ print(f" Plot: {args.output_plot}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/reproduce_scaling.py b/test/reproduce_scaling.py
new file mode 100644
index 0000000..e3639d6
--- /dev/null
+++ b/test/reproduce_scaling.py
@@ -0,0 +1,464 @@
+"""
+Adaptive Moment 120-Particle x 80-Epoch MNIST Scaling Replication Check
+
+Validates the published 120-particle x 80-epoch fixed-epoch Adaptive Moment MNIST scaling result.
+Performs exact replay on seeds 71-75 and fresh independent cohort evaluation on seeds 81-85.
+
+Predeclared Acceptance Criteria:
+1. Exact Replay (seeds 71-75): Max per-seed absolute test accuracy delta <= 0.005 (0.5%p).
+2. Independent Cohort (seeds 81-85): Mean test accuracy absolute difference <= 0.03 (3%p)
+ AND 95% t-confidence intervals overlap between baseline and independent cohorts.
+"""
+
+import argparse
+import csv
+import datetime
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+import torch
+from sklearn.decomposition import PCA
+
+# Path setup for imports from test/ directory
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from benchmark_suite import (
+ calc_stats,
+ compute_data_fingerprint,
+ get_hardware_provenance,
+ resolve_execution_device,
+ save_json_atomic,
+)
+from pso import __version__ as pso_version
+from tuning_suite import (
+ TUNING_PROTOCOL_VERSION,
+ CandidateConfig,
+ get_mnist_raw_data,
+ get_search_candidates,
+ run_single_experiment,
+)
+
+REPLAY_TOLERANCE = 0.005
+INDEPENDENT_MEAN_MARGIN = 0.03
+REPLICATION_PROTOCOL_VERSION = "1.0.0"
+REPLAY_SEEDS = [71, 72, 73, 74, 75]
+INDEPENDENT_SEEDS = [81, 82, 83, 84, 85]
+
+
+def validate_and_load_baseline(
+ baseline_path: Path,
+) -> Tuple[Dict[str, Any], List[Dict[str, Any]], CandidateConfig, str]:
+ if not baseline_path.exists():
+ raise FileNotFoundError(f"Baseline JSON file not found at: {baseline_path}")
+
+ with open(baseline_path, "r", encoding="utf-8") as f:
+ baseline_data = json.load(f)
+
+ if baseline_data.get("tuning_protocol_version") != TUNING_PROTOCOL_VERSION:
+ raise ValueError(
+ "Baseline tuning protocol mismatch: "
+ f"expected {TUNING_PROTOCOL_VERSION}, "
+ f"got {baseline_data.get('tuning_protocol_version')}"
+ )
+ if baseline_data.get("quick") is not False:
+ raise ValueError("Replication requires the full, non-quick tuning baseline.")
+
+ winners = baseline_data.get("winners", {})
+ if "adaptive_moment" not in winners:
+ raise ValueError(f"Baseline JSON {baseline_path} missing 'adaptive_moment' winner entry.")
+
+ am_winner_info = winners["adaptive_moment"]
+ winner_label = am_winner_info.get("candidate_label")
+
+ all_candidates = get_search_candidates()
+ am_candidates = all_candidates.get("adaptive_moment", [])
+ winner_cfg = None
+ for cfg in am_candidates:
+ if cfg.candidate_label == winner_label:
+ winner_cfg = cfg
+ break
+
+ if winner_cfg is None:
+ raise ValueError(
+ f"Could not find CandidateConfig matching label '{winner_label}' in search candidates."
+ )
+ expected_optimizer_config = winner_cfg.to_optimizer_kwargs(quick=False)
+ if am_winner_info.get("config") != expected_optimizer_config:
+ raise ValueError(
+ "Adaptive Moment winner configuration in the baseline no longer matches "
+ f"CandidateConfig '{winner_label}'."
+ )
+
+
+ scaling_runs = baseline_data.get("scaling_runs", [])
+ baseline_records = []
+ for r in scaling_runs:
+ if (
+ r.get("completed")
+ and r.get("method") == "adaptive_moment"
+ and r.get("candidate_label") == winner_label
+ and r.get("n_particles") == 120
+ and r.get("epochs") == 80
+ and r.get("regimen") == "fixed_epoch"
+ and r.get("seed") in REPLAY_SEEDS
+ ):
+ baseline_records.append(r)
+
+ baseline_records.sort(key=lambda x: x["seed"])
+
+ if len(baseline_records) != 5:
+ raise ValueError(
+ f"Expected exactly 5 baseline records for seeds {REPLAY_SEEDS}, "
+ f"found {len(baseline_records)} in {baseline_path}."
+ )
+
+ expected_seeds = sorted(REPLAY_SEEDS)
+ actual_seeds = [r["seed"] for r in baseline_records]
+ if actual_seeds != expected_seeds:
+ raise ValueError(f"Baseline seeds mismatch: expected {expected_seeds}, got {actual_seeds}")
+
+ expected_fp = baseline_data.get("split_fingerprints", {}).get("full")
+ if not isinstance(expected_fp, str) or not expected_fp:
+ raise ValueError("Baseline JSON is missing split_fingerprints.full.")
+ for r in baseline_records:
+ if r.get("data_fingerprint") != expected_fp:
+ raise ValueError(
+ f"Baseline run seed {r['seed']} data_fingerprint {r.get('data_fingerprint')} "
+ f"does not match split_fingerprints.full {expected_fp}"
+ )
+ run_config = r.get("config", {})
+ for key, value in expected_optimizer_config.items():
+ if run_config.get(key) != value:
+ raise ValueError(
+ f"Baseline run seed {r['seed']} config[{key!r}]={run_config.get(key)!r} "
+ f"does not match selected winner value {value!r}."
+ )
+ expected_run_config = {
+ "n_particles": 120,
+ "epochs": 80,
+ "batch_size": 1000,
+ "renewal": "loss",
+ }
+ for key, value in expected_run_config.items():
+ if run_config.get(key) != value:
+ raise ValueError(
+ f"Baseline run seed {r['seed']} config[{key!r}]={run_config.get(key)!r}; "
+ f"expected {value!r}."
+ )
+
+ return baseline_data, baseline_records, winner_cfg, expected_fp
+
+
+def prepare_full_pca_data() -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, str]:
+ x_train_raw, x_test_raw, y_train_3000, y_test_1000 = get_mnist_raw_data()
+ pca_full = PCA(n_components=32, whiten=True, random_state=42)
+ x_full_tr = torch.tensor(pca_full.fit_transform(x_train_raw), dtype=torch.float32)
+ x_full_test = torch.tensor(pca_full.transform(x_test_raw), dtype=torch.float32)
+ data_fp = compute_data_fingerprint(x_full_tr, x_full_test, y_train_3000, y_test_1000)
+ return x_full_tr, y_train_3000, x_full_test, y_test_1000, data_fp
+
+
+def run_replication_cohort(
+ cfg: CandidateConfig,
+ seeds: List[int],
+ x_train: torch.Tensor,
+ y_train: torch.Tensor,
+ x_eval: torch.Tensor,
+ y_eval: torch.Tensor,
+ device: torch.device,
+ data_fp: str,
+ run_type: str,
+) -> List[Dict[str, Any]]:
+ runs = []
+ for seed in seeds:
+ res = run_single_experiment(
+ cfg=cfg,
+ seed=seed,
+ x_train=x_train,
+ y_train=y_train,
+ x_eval=x_eval,
+ y_eval=y_eval,
+ n_particles=120,
+ epochs=80,
+ batch_size=1000,
+ device=device,
+ quick=False,
+ eval_metric_name="test",
+ data_fp=data_fp,
+ run_type=run_type,
+ extra_meta={"regimen": "fixed_epoch"},
+ )
+ runs.append(res)
+ return runs
+
+
+def evaluate_replication(
+ baseline_records: List[Dict[str, Any]],
+ replay_runs: List[Dict[str, Any]],
+ independent_runs: List[Dict[str, Any]],
+) -> Tuple[Dict[str, Any], Dict[str, float], Dict[str, float], Dict[str, float]]:
+ base_acc_by_seed = {r["seed"]: float(r["test_acc"]) for r in baseline_records}
+ replay_acc_by_seed = {r["seed"]: float(r["test_acc"]) for r in replay_runs}
+ expected_seeds = set(REPLAY_SEEDS)
+ if set(base_acc_by_seed) != expected_seeds or set(replay_acc_by_seed) != expected_seeds:
+ raise ValueError("Baseline and replay cohorts must each contain exactly seeds 71-75.")
+ if len(independent_runs) != len(INDEPENDENT_SEEDS) or {
+ r["seed"] for r in independent_runs
+ } != set(INDEPENDENT_SEEDS):
+ raise ValueError("Independent cohort must contain exactly seeds 81-85.")
+
+ baseline_model_fp = {r["seed"]: r.get("model_fingerprint") for r in baseline_records}
+ replay_model_fp = {r["seed"]: r.get("model_fingerprint") for r in replay_runs}
+ replay_model_fingerprint_match = baseline_model_fp == replay_model_fp
+ replay_deltas = {}
+ max_replay_delta = 0.0
+ for seed in sorted(base_acc_by_seed.keys()):
+ b_acc = base_acc_by_seed[seed]
+ r_acc = replay_acc_by_seed[seed]
+ delta = abs(r_acc - b_acc)
+ replay_deltas[str(seed)] = round(delta, 6)
+ if delta > max_replay_delta:
+ max_replay_delta = delta
+
+ replay_pass = bool(max_replay_delta <= REPLAY_TOLERANCE)
+
+ baseline_accs = [base_acc_by_seed[s] for s in sorted(base_acc_by_seed.keys())]
+ replay_accs = [replay_acc_by_seed[s] for s in sorted(replay_acc_by_seed.keys())]
+ indep_accs = [float(r["test_acc"]) for r in independent_runs]
+
+ baseline_stats = calc_stats(baseline_accs)
+ replay_stats = calc_stats(replay_accs)
+ independent_stats = calc_stats(indep_accs)
+
+ indep_mean_diff = abs(independent_stats["mean"] - baseline_stats["mean"])
+ independent_mean_pass = bool(indep_mean_diff <= INDEPENDENT_MEAN_MARGIN)
+
+ baseline_ci_low = round(baseline_stats["mean"] - baseline_stats["ci95_t"], 6)
+ baseline_ci_high = round(baseline_stats["mean"] + baseline_stats["ci95_t"], 6)
+
+ indep_ci_low = round(independent_stats["mean"] - independent_stats["ci95_t"], 6)
+ indep_ci_high = round(independent_stats["mean"] + independent_stats["ci95_t"], 6)
+
+ ci_overlap_pass = bool(max(baseline_ci_low, indep_ci_low) <= min(baseline_ci_high, indep_ci_high))
+ independent_pass = bool(independent_mean_pass and ci_overlap_pass)
+
+ comparison = {
+ "replay_per_seed_deltas": replay_deltas,
+ "replay_max_abs_delta": round(max_replay_delta, 6),
+ "replay_model_fingerprint_match": replay_model_fingerprint_match,
+ "replay_pass": bool(replay_pass and replay_model_fingerprint_match),
+ "independent_mean_abs_diff": round(indep_mean_diff, 6),
+ "independent_mean_pass": independent_mean_pass,
+ "baseline_ci95_t_interval": [baseline_ci_low, baseline_ci_high],
+ "independent_ci95_t_interval": [indep_ci_low, indep_ci_high],
+ "ci_overlap_pass": ci_overlap_pass,
+ "independent_pass": independent_pass,
+ "overall_pass": bool(
+ replay_pass and replay_model_fingerprint_match and independent_pass
+ ),
+ }
+
+ return comparison, baseline_stats, replay_stats, independent_stats
+
+
+def write_replication_csv(
+ baseline_records: List[Dict[str, Any]],
+ replay_runs: List[Dict[str, Any]],
+ independent_runs: List[Dict[str, Any]],
+ output_csv: Path,
+):
+ output_csv.parent.mkdir(parents=True, exist_ok=True)
+ fields = [
+ "cohort",
+ "method",
+ "candidate_label",
+ "regimen",
+ "seed",
+ "n_particles",
+ "epochs",
+ "particle_epochs",
+ "train_loss",
+ "train_acc",
+ "test_loss",
+ "test_acc",
+ "test_mse",
+ "fit_time_sec",
+ "data_fingerprint",
+ "model_fingerprint",
+ "device",
+ "completed",
+ "error",
+ ]
+ all_rows = []
+ for r in baseline_records:
+ row = dict(r)
+ row["cohort"] = "baseline"
+ all_rows.append(row)
+ for r in replay_runs:
+ row = dict(r)
+ row["cohort"] = "replay"
+ all_rows.append(row)
+ for r in independent_runs:
+ row = dict(r)
+ row["cohort"] = "independent"
+ all_rows.append(row)
+
+ with open(output_csv, "w", newline="", encoding="utf-8") as f:
+ writer = csv.DictWriter(f, fieldnames=fields, extrasaction="ignore")
+ writer.writeheader()
+ for r in all_rows:
+ writer.writerow(r)
+
+
+def main():
+ parser = argparse.ArgumentParser(
+ description="Replicate and verify published Adaptive Moment 120p x 80e MNIST scaling result"
+ )
+ parser.add_argument(
+ "--baseline-json",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_tuning.json"),
+ help="Path to baseline tuning JSON",
+ )
+ parser.add_argument(
+ "--output-json",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_120p80_replication.json"),
+ help="Path for replication output JSON",
+ )
+ parser.add_argument(
+ "--output-csv",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_120p80_replication.csv"),
+ help="Path for replication output CSV",
+ )
+ parser.add_argument(
+ "--device",
+ type=str,
+ default=None,
+ help="Execution device (cpu, cuda, mps)",
+ )
+
+ args = parser.parse_args()
+ device = resolve_execution_device(args.device)
+
+ print("=== Adaptive Moment 120p x 80e Replication Check ===")
+ print(f"Device: {device}")
+ print(f"Baseline JSON: {args.baseline_json}")
+ print(f"Output JSON: {args.output_json}")
+ print(f"Output CSV: {args.output_csv}")
+
+ baseline_data, baseline_records, winner_cfg, expected_fp = validate_and_load_baseline(
+ args.baseline_json
+ )
+ print(f"Validated baseline winner '{winner_cfg.candidate_label}' across 5 records.")
+ if baseline_data.get("device") != str(device):
+ raise ValueError(
+ f"Exact replay requires baseline device {baseline_data.get('device')!r}; "
+ f"got {str(device)!r}."
+ )
+ if baseline_data.get("pso_version") != pso_version:
+ raise ValueError(
+ f"Exact replay requires pso version {baseline_data.get('pso_version')!r}; "
+ f"got {pso_version!r}."
+ )
+ if baseline_data.get("torch_version") != torch.__version__:
+ raise ValueError(
+ f"Exact replay requires torch version {baseline_data.get('torch_version')!r}; "
+ f"got {torch.__version__!r}."
+ )
+
+ x_full_tr, y_train_3000, x_full_test, y_test_1000, data_fp = prepare_full_pca_data()
+ if expected_fp and data_fp != expected_fp:
+ raise ValueError(
+ f"Reconstructed data fingerprint {data_fp} does not match baseline {expected_fp}"
+ )
+ print(f"Reconstructed PCA32 data (fingerprint: {data_fp})")
+
+ print("\n--- Running Cohort 1: Exact Replay (Seeds 71-75) ---")
+ replay_runs = run_replication_cohort(
+ cfg=winner_cfg,
+ seeds=REPLAY_SEEDS,
+ x_train=x_full_tr,
+ y_train=y_train_3000,
+ x_eval=x_full_test,
+ y_eval=y_test_1000,
+ device=device,
+ data_fp=data_fp,
+ run_type="replication_replay",
+ )
+
+ print("\n--- Running Cohort 2: Independent Fresh Seeds (Seeds 81-85) ---")
+ independent_runs = run_replication_cohort(
+ cfg=winner_cfg,
+ seeds=INDEPENDENT_SEEDS,
+ x_train=x_full_tr,
+ y_train=y_train_3000,
+ x_eval=x_full_test,
+ y_eval=y_test_1000,
+ device=device,
+ data_fp=data_fp,
+ run_type="replication_independent",
+ )
+
+ comparison, baseline_stats, replay_stats, independent_stats = evaluate_replication(
+ baseline_records, replay_runs, independent_runs
+ )
+
+ payload = {
+ "replication_protocol_version": REPLICATION_PROTOCOL_VERSION,
+ "source_tuning_protocol_version": baseline_data["tuning_protocol_version"],
+ "pso_version": pso_version,
+ "torch_version": torch.__version__,
+ "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+ "device": str(device),
+ "hardware": get_hardware_provenance(device),
+ "baseline_json": str(args.baseline_json),
+ "source_tuning_timestamp": baseline_data.get("timestamp"),
+ "candidate_label": winner_cfg.candidate_label,
+ "config": winner_cfg.to_optimizer_kwargs(),
+ "data_fingerprint": data_fp,
+ "criteria": {
+ "replay_seeds": REPLAY_SEEDS,
+ "replay_max_abs_delta_tolerance": REPLAY_TOLERANCE,
+ "require_replay_model_fingerprint_match": True,
+ "independent_seeds": INDEPENDENT_SEEDS,
+ "independent_mean_abs_diff_margin": INDEPENDENT_MEAN_MARGIN,
+ "require_ci_overlap": True,
+ },
+ "summaries": {
+ "baseline": baseline_stats,
+ "replay": replay_stats,
+ "independent": independent_stats,
+ },
+ "comparison": comparison,
+ "baseline_runs": baseline_records,
+ "replay_runs": replay_runs,
+ "independent_runs": independent_runs,
+ "completed": True,
+ "error": None,
+ }
+
+ save_json_atomic(payload, args.output_json)
+ write_replication_csv(baseline_records, replay_runs, independent_runs, args.output_csv)
+
+ print("\n=== Replication Results Summary ===")
+ print(f"Baseline Mean Test Acc: {baseline_stats['mean']:.4f} ± {baseline_stats['std']:.4f}")
+ print(f"Replay Mean Test Acc: {replay_stats['mean']:.4f} ± {replay_stats['std']:.4f}")
+ print(f"Independent Mean Test Acc: {independent_stats['mean']:.4f} ± {independent_stats['std']:.4f}")
+ print(f"Max Replay Delta: {comparison['replay_max_abs_delta']:.6f} (Limit: {REPLAY_TOLERANCE}) -> Pass: {comparison['replay_pass']}")
+ print(f"Indep Mean Diff: {comparison['independent_mean_abs_diff']:.6f} (Limit: {INDEPENDENT_MEAN_MARGIN}) -> Pass: {comparison['independent_mean_pass']}")
+ print(f"CI Overlap Pass: {comparison['ci_overlap_pass']} (Baseline CI: {comparison['baseline_ci95_t_interval']}, Indep CI: {comparison['independent_ci95_t_interval']})")
+ print(f"OVERALL PASS: {comparison['overall_pass']}")
+
+ if not comparison["overall_pass"]:
+ print("\nREPLICATION CHECK FAILED!")
+ sys.exit(1)
+ else:
+ print("\nREPLICATION CHECK PASSED!")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/seeds.py b/test/seeds.py
index bb5b79f..135c0a7 100644
--- a/test/seeds.py
+++ b/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()
diff --git a/test/tuning_suite.py b/test/tuning_suite.py
new file mode 100644
index 0000000..845ed11
--- /dev/null
+++ b/test/tuning_suite.py
@@ -0,0 +1,1432 @@
+"""
+MNIST Tuning & Particle Scaling Study Suite (v4.0 Protocol 1.0.0)
+
+Implements a reproducible three-phase study:
+1. Search Phase: Inner validation split (2400 train / 600 val, stratified) from first 3000 MNIST training examples.
+ Fit PCA32 whitening on inner train only; transform inner val.
+ Evaluates candidate space across 5 movement methods (adaptive_moment, inertia, constriction, local_best, quantum) over 3 seeds (51-53).
+ Ranks validation accuracy descending, then validation loss ascending.
+2. Confirmation Phase: Full 3000 training examples and 1000 untouched test examples.
+ Fit PCA32 whitening on full 3000 train only; transform 1000 test.
+ Evaluates top candidate per method over 5 seeds (61-65).
+3. Scaling Phase: Full 3000 training / 1000 test set.
+ Evaluates selected adaptive_moment winner across particle counts 30, 60, 90, 120
+ under fixed-epoch (80) and fixed-budget (~2400 particle-epochs) regimens over 5 seeds (71-75).
+"""
+
+import argparse
+import dataclasses
+import hashlib
+import json
+import csv
+import math
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+from sklearn.decomposition import PCA
+from sklearn.model_selection import train_test_split
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from benchmark_suite import (
+ METHOD_STYLE,
+ calc_stats,
+ compute_data_fingerprint,
+ compute_model_fingerprint,
+ extract_plugin_metadata,
+ get_hardware_provenance,
+ get_method_style,
+ get_t_crit,
+ make_mnist_model,
+ resolve_execution_device,
+ save_json_atomic,
+ sync_device,
+)
+from pso import Optimizer, __version__ as pso_version
+
+TUNING_PROTOCOL_VERSION = "1.0.0"
+
+
+@dataclasses.dataclass
+class CandidateConfig:
+ method: str
+ candidate_label: str
+ description: str
+ c0: float = 1.49618
+ c1: float = 1.49618
+ w_min: float = 0.7298
+ w_max: float = 0.7298
+ velocity_limit_ratio: Optional[float] = 0.025
+ mutation_swarm: float = 0.02
+ negative_swarm: float = 0.0
+ method_options: Dict[str, Any] = dataclasses.field(default_factory=dict)
+
+ def to_optimizer_kwargs(self, quick: bool = False) -> Dict[str, Any]:
+ fitness_sz = 50 if quick else 2000
+ kwargs: Dict[str, Any] = {
+ "method": self.method,
+ "velocity_limit_ratio": self.velocity_limit_ratio,
+ "mutation_swarm": self.mutation_swarm,
+ "negative_swarm": self.negative_swarm,
+ "particle_min": -3.0,
+ "particle_max": 3.0,
+ "boundary_strategy": "reflect",
+ "initialization": "model_noise",
+ "initial_position_noise": 0.05,
+ "evaluation": "fixed_subset",
+ "fitness_size": fitness_sz,
+ "convergence": "none",
+ "refinement": "none",
+ }
+ if self.method in ("adaptive_moment", "inertia", "local_best"):
+ kwargs["c0"] = self.c0
+ kwargs["c1"] = self.c1
+ kwargs["w_min"] = self.w_min
+ kwargs["w_max"] = self.w_max
+ elif self.method == "constriction":
+ kwargs["c0"] = self.c0
+ kwargs["c1"] = self.c1
+
+ if self.method_options:
+ kwargs["method_options"] = dict(self.method_options)
+ return kwargs
+
+
+def get_mnist_raw_data() -> Tuple[np.ndarray, np.ndarray, torch.Tensor, torch.Tensor]:
+ from torchvision.datasets import MNIST
+ cache_dir = Path("result/cache")
+ cache_dir.mkdir(parents=True, exist_ok=True)
+ train_dataset = MNIST(root=str(cache_dir), train=True, download=True)
+ test_dataset = MNIST(root=str(cache_dir), train=False, download=True)
+
+ x_train_raw = (train_dataset.data[:3000].float() / 255.0).reshape(3000, -1).numpy()
+ y_train = train_dataset.targets[:3000].long()
+
+ x_test_raw = (test_dataset.data[:1000].float() / 255.0).reshape(1000, -1).numpy()
+ y_test = test_dataset.targets[:1000].long()
+
+ return x_train_raw, x_test_raw, y_train, y_test
+
+
+def get_search_candidates() -> Dict[str, List[CandidateConfig]]:
+ candidates: Dict[str, List[CandidateConfig]] = {
+ "adaptive_moment": [],
+ "inertia": [],
+ "constriction": [],
+ "local_best": [],
+ "quantum": [],
+ }
+
+ # --- 1. Adaptive Moment Candidates ---
+ blends = [0.03, 0.06, 0.10, 0.15]
+ steps = [0.5, 1.0, 1.5]
+ for b in blends:
+ for s in steps:
+ label = f"am_b{b}_s{s}"
+ candidates["adaptive_moment"].append(
+ CandidateConfig(
+ method="adaptive_moment",
+ candidate_label=label,
+ description=f"Adaptive Moment blend={b}, step={s}, beta1=0.9",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ method_options={"moment_blend": b, "moment_step_size": s, "moment_beta1": 0.9},
+ )
+ )
+ for beta1 in [0.8, 0.95]:
+ label = f"am_b0.06_s1.0_beta{beta1}"
+ candidates["adaptive_moment"].append(
+ CandidateConfig(
+ method="adaptive_moment",
+ candidate_label=label,
+ description=f"Adaptive Moment blend=0.06, step=1.0, beta1={beta1}",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ method_options={"moment_blend": 0.06, "moment_step_size": 1.0, "moment_beta1": beta1},
+ )
+ )
+
+ # --- 2. Inertia Candidates ---
+ candidates["inertia"] = [
+ CandidateConfig(
+ method="inertia",
+ candidate_label="inertia_canonical",
+ description="Canonical Inertia (c0=c1=2.0, w=0.9->0.4, vel=0.1, mut=0)",
+ c0=2.0,
+ c1=2.0,
+ w_min=0.4,
+ w_max=0.9,
+ velocity_limit_ratio=0.1,
+ mutation_swarm=0.0,
+ ),
+ CandidateConfig(
+ method="inertia",
+ candidate_label="inertia_tuned",
+ description="Tuned Inertia (c0=c1=1.49618, w=0.7298, vel=0.025, mut=0.02)",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ ),
+ CandidateConfig(
+ method="inertia",
+ candidate_label="inertia_low_w",
+ description="Low Inertia w (c0=c1=1.49618, w=0.55, vel=0.025, mut=0.02)",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.55,
+ w_max=0.55,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ ),
+ CandidateConfig(
+ method="inertia",
+ candidate_label="inertia_w_decay",
+ description="Decaying Inertia (c0=c1=1.49618, w=0.9->0.4, vel=0.025, mut=0.02)",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.4,
+ w_max=0.9,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ ),
+ CandidateConfig(
+ method="inertia",
+ candidate_label="inertia_asymmetric",
+ description="Asymmetric Inertia (c0=1.8, c1=1.2, w=0.7298, vel=0.025, mut=0.02)",
+ c0=1.8,
+ c1=1.2,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ ),
+ ]
+
+ # --- 3. Constriction Candidates ---
+ candidates["constriction"] = [
+ CandidateConfig(
+ method="constriction",
+ candidate_label="constriction_c201",
+ description="Constriction c0=c1=2.01 (vel=0.025, mut=0)",
+ c0=2.01,
+ c1=2.01,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.0,
+ ),
+ CandidateConfig(
+ method="constriction",
+ candidate_label="constriction_c205_canonical",
+ description="Constriction c0=c1=2.05 canonical-ish (vel=0.05, mut=0.02)",
+ c0=2.05,
+ c1=2.05,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.05,
+ mutation_swarm=0.02,
+ ),
+ CandidateConfig(
+ method="constriction",
+ candidate_label="constriction_c205_tuned",
+ description="Constriction c0=c1=2.05 tuned (vel=0.025, mut=0)",
+ c0=2.05,
+ c1=2.05,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.0,
+ ),
+ CandidateConfig(
+ method="constriction",
+ candidate_label="constriction_c250",
+ description="Constriction c0=c1=2.50 (vel=0.025, mut=0)",
+ c0=2.50,
+ c1=2.50,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.0,
+ ),
+ CandidateConfig(
+ method="constriction",
+ candidate_label="constriction_asymmetric",
+ description="Asymmetric Constriction c0=2.8, c1=1.3 (vel=0.025, mut=0)",
+ c0=2.8,
+ c1=1.3,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.0,
+ ),
+ ]
+
+ # --- 4. Local-Best Candidates ---
+ candidates["local_best"] = [
+ CandidateConfig(
+ method="local_best",
+ candidate_label="local_best_r1_constant",
+ description="Local Best Ring Radius 1 (constant w=0.7298)",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ method_options={"neighborhood_radius": 1, "c0": 1.49618, "c1": 1.49618, "w_min": 0.7298, "w_max": 0.7298},
+ ),
+ CandidateConfig(
+ method="local_best",
+ candidate_label="local_best_r2_constant",
+ description="Local Best Ring Radius 2 (constant w=0.7298)",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ method_options={"neighborhood_radius": 2, "c0": 1.49618, "c1": 1.49618, "w_min": 0.7298, "w_max": 0.7298},
+ ),
+ CandidateConfig(
+ method="local_best",
+ candidate_label="local_best_r4_constant",
+ description="Local Best Ring Radius 4 (constant w=0.7298)",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ method_options={"neighborhood_radius": 4, "c0": 1.49618, "c1": 1.49618, "w_min": 0.7298, "w_max": 0.7298},
+ ),
+ CandidateConfig(
+ method="local_best",
+ candidate_label="local_best_r1_decay",
+ description="Local Best Ring Radius 1 (decaying w=0.9->0.4)",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.4,
+ w_max=0.9,
+ velocity_limit_ratio=0.025,
+ mutation_swarm=0.02,
+ method_options={"neighborhood_radius": 1, "c0": 1.49618, "c1": 1.49618, "w_min": 0.4, "w_max": 0.9},
+ ),
+ ]
+
+ # --- 5. Quantum Candidates ---
+ candidates["quantum"] = [
+ CandidateConfig(
+ method="quantum",
+ candidate_label="quantum_beta_0.5_1.0",
+ description="Quantum PSO (beta=1.0->0.5)",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=None,
+ mutation_swarm=0.0,
+ negative_swarm=0.0,
+ method_options={"beta_min": 0.5, "beta_max": 1.0},
+ ),
+ CandidateConfig(
+ method="quantum",
+ candidate_label="quantum_beta_0.6_1.0",
+ description="Quantum PSO (beta=1.0->0.6)",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=None,
+ mutation_swarm=0.0,
+ negative_swarm=0.0,
+ method_options={"beta_min": 0.6, "beta_max": 1.0},
+ ),
+ CandidateConfig(
+ method="quantum",
+ candidate_label="quantum_beta_0.5_1.2",
+ description="Quantum PSO (beta=1.2->0.5)",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=None,
+ mutation_swarm=0.0,
+ negative_swarm=0.0,
+ method_options={"beta_min": 0.5, "beta_max": 1.2},
+ ),
+ CandidateConfig(
+ method="quantum",
+ candidate_label="quantum_beta_0.4_0.9",
+ description="Quantum PSO (beta=0.9->0.4)",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.7298,
+ w_max=0.7298,
+ velocity_limit_ratio=None,
+ mutation_swarm=0.0,
+ negative_swarm=0.0,
+ method_options={"beta_min": 0.4, "beta_max": 0.9},
+ ),
+ ]
+
+ return candidates
+
+
+def run_single_experiment(
+ cfg: CandidateConfig,
+ seed: int,
+ x_train: torch.Tensor,
+ y_train: torch.Tensor,
+ x_eval: torch.Tensor,
+ y_eval: torch.Tensor,
+ n_particles: int,
+ epochs: int,
+ batch_size: int,
+ device: torch.device,
+ quick: bool = False,
+ eval_metric_name: str = "val",
+ data_fp: str = "",
+ run_type: str = "search",
+ extra_meta: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+ opt_kwargs = cfg.to_optimizer_kwargs(quick=quick)
+ hw_provenance = get_hardware_provenance(device)
+ warmup_ep = min(2, epochs)
+
+ # --- Untimed Warmup Phase ---
+ warmup_model = make_mnist_model(seed=seed)
+ warmup_loss = nn.CrossEntropyLoss()
+ warmup_opt = Optimizer(
+ model=warmup_model,
+ loss=warmup_loss,
+ task="multiclass",
+ n_particles=n_particles,
+ seed=seed,
+ device=device,
+ **opt_kwargs,
+ )
+ warmup_opt.fit(
+ x_train,
+ y_train,
+ epochs=warmup_ep,
+ batch_size=batch_size,
+ renewal="loss",
+ )
+ sync_device(device)
+ del warmup_opt, warmup_model, warmup_loss
+
+ # --- Timed Fit Phase ---
+ model = make_mnist_model(seed=seed)
+ model_fp = compute_model_fingerprint(model)
+ loss_inst = nn.CrossEntropyLoss()
+
+ opt = Optimizer(
+ model=model,
+ loss=loss_inst,
+ task="multiclass",
+ n_particles=n_particles,
+ seed=seed,
+ device=device,
+ **opt_kwargs,
+ )
+
+ plugin_meta = extract_plugin_metadata(opt)
+
+ sync_device(device)
+ t0 = time.perf_counter()
+
+ train_loss, train_acc, train_mse = opt.fit(
+ x_train,
+ y_train,
+ epochs=epochs,
+ batch_size=batch_size,
+ renewal="loss",
+ )
+ sync_device(device)
+ t1 = time.perf_counter()
+ fit_time = t1 - t0
+
+ # Separate Evaluation on Validation or Test set
+ eval_loss, eval_acc, eval_mse = opt.evaluate(x_eval, y_eval)
+
+ full_resolved_config = dict(opt_kwargs)
+ full_resolved_config.update({
+ "n_particles": n_particles,
+ "epochs": epochs,
+ "batch_size": batch_size,
+ "renewal": "loss",
+ })
+
+ res = {
+ "protocol_version": TUNING_PROTOCOL_VERSION,
+ "pso_version": pso_version,
+ "torch_version": torch.__version__,
+ "hardware": hw_provenance,
+ "timing_scope": "fit_only_after_method_specific_warmup",
+ "warmup_epochs": warmup_ep,
+ "error": None,
+ "phase": run_type,
+ "method": cfg.method,
+ "candidate_label": cfg.candidate_label,
+ "seed": seed,
+ "n_particles": n_particles,
+ "epochs": epochs,
+ "particle_epochs": n_particles * epochs,
+ "train_loss": float(train_loss),
+ "train_acc": float(train_acc),
+ "train_mse": float(train_mse),
+ f"{eval_metric_name}_loss": float(eval_loss),
+ f"{eval_metric_name}_acc": float(eval_acc),
+ f"{eval_metric_name}_mse": float(eval_mse),
+ "fit_time_sec": float(fit_time),
+ "data_fingerprint": data_fp,
+ "model_fingerprint": model_fp,
+ "device": str(device),
+ "completed": True,
+ "plugins": plugin_meta,
+ "config": full_resolved_config,
+ }
+ if extra_meta:
+ res.update(extra_meta)
+ return res
+
+
+def write_tuning_csvs(
+ search_runs: List[Dict[str, Any]],
+ confirmation_runs: List[Dict[str, Any]],
+ scaling_runs: List[Dict[str, Any]],
+ result_dir: Path,
+):
+ result_dir.mkdir(parents=True, exist_ok=True)
+
+ # 1. Search CSV
+ search_csv = result_dir / "pso_v4_tuning_search.csv"
+ search_fields = [
+ "method", "candidate_label", "seed", "n_particles", "epochs", "particle_epochs",
+ "train_loss", "train_acc", "val_loss", "val_acc", "val_mse",
+ "fit_time_sec", "data_fingerprint", "model_fingerprint", "device"
+ ]
+ with open(search_csv, "w", newline="", encoding="utf-8") as f:
+ writer = csv.DictWriter(f, fieldnames=search_fields, extrasaction="ignore")
+ writer.writeheader()
+ for r in search_runs:
+ if r.get("completed"):
+ writer.writerow(r)
+
+ # 2. Confirmation CSV
+ confirm_csv = result_dir / "pso_v4_tuning_confirmation.csv"
+ confirm_fields = [
+ "method", "candidate_label", "seed", "n_particles", "epochs", "particle_epochs",
+ "train_loss", "train_acc", "test_loss", "test_acc", "test_mse",
+ "fit_time_sec", "data_fingerprint", "model_fingerprint", "device"
+ ]
+ with open(confirm_csv, "w", newline="", encoding="utf-8") as f:
+ writer = csv.DictWriter(f, fieldnames=confirm_fields, extrasaction="ignore")
+ writer.writeheader()
+ for r in confirmation_runs:
+ if r.get("completed"):
+ writer.writerow(r)
+
+ # 3. Particle Scaling CSV
+ scaling_csv = result_dir / "pso_v4_particle_scaling.csv"
+ scaling_fields = [
+ "method", "candidate_label", "regimen", "n_particles", "epochs", "particle_epochs", "seed",
+ "train_loss", "train_acc", "test_loss", "test_acc", "test_mse",
+ "fit_time_sec", "data_fingerprint", "model_fingerprint", "device"
+ ]
+ with open(scaling_csv, "w", newline="", encoding="utf-8") as f:
+ writer = csv.DictWriter(f, fieldnames=scaling_fields, extrasaction="ignore")
+ writer.writeheader()
+ for r in scaling_runs:
+ if r.get("completed"):
+ writer.writerow(r)
+
+
+def _persist_json_state(
+ output_json: Path,
+ device: torch.device,
+ quick: bool,
+ hw_provenance: Dict[str, Any],
+ split_fingerprints: Dict[str, str],
+ pca_provenance: Dict[str, Any],
+ all_search_candidates: Dict[str, List[CandidateConfig]],
+ search_runs: List[Dict[str, Any]],
+ confirmation_runs: List[Dict[str, Any]],
+ scaling_runs: List[Dict[str, Any]],
+):
+ search_summaries: Dict[str, Any] = {}
+ for r in search_runs:
+ if not r.get("completed"):
+ continue
+ lbl = r["candidate_label"]
+ if lbl not in search_summaries:
+ search_summaries[lbl] = {
+ "method": r["method"],
+ "candidate_label": lbl,
+ "val_accs": [],
+ "val_losses": [],
+ "fit_times": [],
+ }
+ search_summaries[lbl]["val_accs"].append(r["val_acc"])
+ search_summaries[lbl]["val_losses"].append(r["val_loss"])
+ search_summaries[lbl]["fit_times"].append(r["fit_time_sec"])
+
+ for lbl, s in search_summaries.items():
+ s["val_acc_stats"] = calc_stats(s["val_accs"])
+ s["val_loss_stats"] = calc_stats(s["val_losses"])
+ s["fit_time_stats"] = calc_stats(s["fit_times"])
+
+ confirm_summaries: Dict[str, Any] = {}
+ for r in confirmation_runs:
+ if not r.get("completed"):
+ continue
+ m = r["method"]
+ if m not in confirm_summaries:
+ confirm_summaries[m] = {
+ "method": m,
+ "candidate_label": r["candidate_label"],
+ "test_accs": [],
+ "test_losses": [],
+ "fit_times": [],
+ }
+ confirm_summaries[m]["test_accs"].append(r["test_acc"])
+ confirm_summaries[m]["test_losses"].append(r["test_loss"])
+ confirm_summaries[m]["fit_times"].append(r["fit_time_sec"])
+
+ for m, s in confirm_summaries.items():
+ s["test_acc_stats"] = calc_stats(s["test_accs"])
+ s["test_loss_stats"] = calc_stats(s["test_losses"])
+ s["fit_time_stats"] = calc_stats(s["fit_times"])
+
+ scaling_summaries: Dict[str, Any] = {}
+ for r in scaling_runs:
+ if not r.get("completed"):
+ continue
+ key = f"{r['n_particles']}p_{r['epochs']}e_{r.get('regimen', 'unknown')}"
+ if key not in scaling_summaries:
+ scaling_summaries[key] = {
+ "n_particles": r["n_particles"],
+ "epochs": r["epochs"],
+ "particle_epochs": r["particle_epochs"],
+ "regimen": r.get("regimen", "unknown"),
+ "test_accs": [],
+ "test_losses": [],
+ "fit_times": [],
+ }
+ scaling_summaries[key]["test_accs"].append(r["test_acc"])
+ scaling_summaries[key]["test_losses"].append(r["test_loss"])
+ scaling_summaries[key]["fit_times"].append(r["fit_time_sec"])
+
+ for key, s in scaling_summaries.items():
+ s["test_acc_stats"] = calc_stats(s["test_accs"])
+ s["test_loss_stats"] = calc_stats(s["test_losses"])
+ s["fit_time_stats"] = calc_stats(s["fit_times"])
+
+ required_seeds = 1 if quick else 3
+ winners = {}
+ for method, cand_list in all_search_candidates.items():
+ cand_scores = []
+ for cfg in cand_list:
+ lbl = cfg.candidate_label
+ matching_runs = [r for r in search_runs if r.get("candidate_label") == lbl and r.get("completed")]
+ if len(matching_runs) < required_seeds:
+ continue
+ val_accs = [r["val_acc"] for r in matching_runs]
+ val_losses = [r["val_loss"] for r in matching_runs]
+ cand_scores.append({
+ "candidate_label": lbl,
+ "mean_val_loss": float(np.mean(val_losses)),
+ "mean_val_acc": float(np.mean(val_accs)),
+ "config": cfg.to_optimizer_kwargs(quick=quick),
+ })
+ if cand_scores:
+ # Rank validation accuracy descending, then validation loss ascending
+ cand_scores.sort(key=lambda c: (-c["mean_val_acc"], c["mean_val_loss"]))
+ winners[method] = cand_scores[0]
+
+ payload = {
+ "tuning_protocol_version": TUNING_PROTOCOL_VERSION,
+ "pso_version": pso_version,
+ "torch_version": torch.__version__,
+ "quick": quick,
+ "device": str(device),
+ "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+ "hardware": hw_provenance,
+ "split_fingerprints": split_fingerprints,
+ "pca_provenance": pca_provenance,
+ "selection_criteria": "Validation accuracy descending, then validation loss ascending across required search seeds",
+ "winners": winners,
+ "summaries": {
+ "search": search_summaries,
+ "confirmation": confirm_summaries,
+ "scaling": scaling_summaries,
+ },
+ "search_runs": search_runs,
+ "confirmation_runs": confirmation_runs,
+ "scaling_runs": scaling_runs,
+ }
+ save_json_atomic(payload, output_json)
+
+
+def render_tuning_plots(
+ search_runs: List[Dict[str, Any]],
+ confirmation_runs: List[Dict[str, Any]],
+ scaling_runs: List[Dict[str, Any]],
+ winners: Dict[str, Dict[str, Any]],
+ figure_dir: Path,
+):
+ figure_dir.mkdir(parents=True, exist_ok=True)
+
+ # -------------------------------------------------------------
+ # Figure 1: pso_v4_extended_tuning.png
+ # -------------------------------------------------------------
+ fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5.5))
+
+ methods = ["adaptive_moment", "inertia", "constriction", "local_best", "quantum"]
+ method_labels = {
+ "adaptive_moment": "Adaptive Moment",
+ "inertia": "Inertia Weight",
+ "constriction": "Constriction",
+ "local_best": "Local Best",
+ "quantum": "Quantum PSO",
+ }
+
+ positions = []
+ box_data = []
+ winner_x = []
+ winner_y = []
+ x_ticks = []
+ x_tick_labels = []
+
+ for idx, m in enumerate(methods):
+ m_runs = [r for r in search_runs if r.get("method") == m and r.get("completed")]
+ if not m_runs:
+ continue
+ cand_means = {}
+ for r in m_runs:
+ lbl = r["candidate_label"]
+ if lbl not in cand_means:
+ cand_means[lbl] = []
+ cand_means[lbl].append(r["val_loss"])
+
+ c_means = [float(np.mean(vals)) for vals in cand_means.values()]
+ box_data.append(c_means)
+ pos = idx + 1
+ positions.append(pos)
+ x_ticks.append(pos)
+ x_tick_labels.append(method_labels.get(m, m))
+
+ win_info = winners.get(m)
+ if win_info and win_info["candidate_label"] in cand_means:
+ win_loss = float(np.mean(cand_means[win_info["candidate_label"]]))
+ winner_x.append(pos)
+ winner_y.append(win_loss)
+
+ if box_data:
+ bp = ax1.boxplot(
+ box_data,
+ positions=positions,
+ widths=0.45,
+ patch_artist=True,
+ showmeans=False,
+ )
+ for box, m in zip(bp["boxes"], methods[:len(box_data)]):
+ c, _ = get_method_style(m)
+ box.set_facecolor(c)
+ box.set_alpha(0.6)
+ box.set_edgecolor("#333333")
+
+ if winner_x:
+ ax1.scatter(
+ winner_x,
+ winner_y,
+ color="#D55E00",
+ marker="*",
+ s=180,
+ zorder=5,
+ label="Selected Winner Candidate",
+ )
+
+ ax1.set_xticks(x_ticks)
+ ax1.set_xticklabels(x_tick_labels, rotation=15, ha="right", fontsize=10)
+ ax1.set_ylabel("Validation Cross-Entropy Loss", fontsize=11)
+ ax1.set_title("Phase 1: Inner Validation Search (Candidates per Method)", fontsize=12, fontweight="bold")
+ ax1.grid(True, linestyle="--", alpha=0.5)
+ if winner_x:
+ ax1.legend(loc="upper right")
+
+ conf_x = []
+ conf_y = []
+ conf_ci = []
+ conf_colors = []
+
+ for idx, m in enumerate(methods):
+ m_runs = [r for r in confirmation_runs if r.get("method") == m and r.get("completed")]
+ if not m_runs:
+ continue
+ accs = [r["test_acc"] * 100.0 for r in m_runs]
+ stats = calc_stats(accs)
+ conf_x.append(idx + 1)
+ conf_y.append(stats["mean"])
+ conf_ci.append(stats["ci95_t"])
+ c, _ = get_method_style(m)
+ conf_colors.append(c)
+
+ if conf_x:
+ bars = ax2.bar(
+ conf_x,
+ conf_y,
+ yerr=conf_ci,
+ capsize=5,
+ color=conf_colors,
+ edgecolor="#333333",
+ alpha=0.85,
+ width=0.5,
+ )
+ ax2.set_xticks(conf_x)
+ ax2.set_xticklabels([method_labels.get(m, m) for m in methods[:len(conf_x)]], rotation=15, ha="right", fontsize=10)
+ ax2.set_ylabel("Held-Out Test Accuracy (%)", fontsize=11)
+ ax2.set_title("Phase 2: Held-Out Test Confirmation (Method Winners)", fontsize=12, fontweight="bold")
+ ax2.grid(True, linestyle="--", alpha=0.5)
+
+ for bar, y_val, ci_val in zip(bars, conf_y, conf_ci):
+ ax2.text(
+ bar.get_x() + bar.get_width() / 2.0,
+ y_val + ci_val + 0.5,
+ f"{y_val:.1f}%",
+ ha="center",
+ va="bottom",
+ fontsize=9,
+ fontweight="bold",
+ )
+
+ plt.tight_layout()
+ fig_path1 = figure_dir / "pso_v4_extended_tuning.png"
+ plt.savefig(fig_path1, dpi=300, bbox_inches="tight")
+ plt.close(fig)
+ print(f"Rendered plot: {fig_path1}")
+
+ # -------------------------------------------------------------
+ # Figure 2: pso_v4_particle_scaling.png
+ # -------------------------------------------------------------
+ fig, (ax_acc, ax_loss, ax_time) = plt.subplots(1, 3, figsize=(16, 4.8))
+
+ regimens = ["fixed_epoch", "fixed_budget"]
+ regimen_names = {
+ "fixed_epoch": "Fixed epochs: 80",
+ "fixed_budget": "Fixed budget: ~2,400 particle-epochs",
+ }
+ regimen_colors = {
+ "fixed_epoch": "#0072B2",
+ "fixed_budget": "#D55E00",
+ }
+ regimen_markers = {
+ "fixed_epoch": "o",
+ "fixed_budget": "X",
+ }
+
+ for reg in regimens:
+ reg_runs = [r for r in scaling_runs if r.get("regimen") == reg and r.get("completed")]
+ if not reg_runs:
+ continue
+
+ by_p: Dict[int, List[Dict[str, Any]]] = {}
+ for r in reg_runs:
+ p = r["n_particles"]
+ if p not in by_p:
+ by_p[p] = []
+ by_p[p].append(r)
+
+ p_sorted = sorted(by_p.keys())
+ x_offset = -1.2 if reg == "fixed_epoch" else 1.2
+ plot_x = [p + x_offset for p in p_sorted]
+ acc_means, acc_cis = [], []
+ loss_means, loss_cis = [], []
+ time_means, time_cis = [], []
+
+ for p in p_sorted:
+ p_runs = by_p[p]
+ acc_st = calc_stats([r["test_acc"] * 100.0 for r in p_runs])
+ loss_st = calc_stats([r["test_loss"] for r in p_runs])
+ time_st = calc_stats([r["fit_time_sec"] for r in p_runs])
+
+ acc_means.append(acc_st["mean"])
+ acc_cis.append(acc_st["ci95_t"])
+ loss_means.append(loss_st["mean"])
+ loss_cis.append(loss_st["ci95_t"])
+ time_means.append(time_st["mean"])
+ time_cis.append(time_st["ci95_t"])
+
+ color = regimen_colors[reg]
+ marker = regimen_markers[reg]
+ label = regimen_names[reg]
+
+ ax_acc.errorbar(
+ plot_x,
+ acc_means,
+ yerr=acc_cis,
+ fmt=f"-{marker}",
+ color=color,
+ linewidth=2,
+ markersize=6,
+ capsize=4,
+ label=label,
+ )
+
+ ax_loss.errorbar(
+ plot_x,
+ loss_means,
+ yerr=loss_cis,
+ fmt=f"-{marker}",
+ color=color,
+ linewidth=2,
+ markersize=6,
+ capsize=4,
+ label=label,
+ )
+
+ ax_time.errorbar(
+ plot_x,
+ time_means,
+ yerr=time_cis,
+ fmt=f"-{marker}",
+ color=color,
+ linewidth=2,
+ markersize=6,
+ capsize=4,
+ label=label,
+ )
+
+ ax_acc.set_title("Test Accuracy vs Particle Count", fontsize=11, fontweight="bold")
+ ax_acc.set_xlabel("Particle Count", fontsize=10)
+ ax_acc.set_ylabel("Test Accuracy (%)", fontsize=10)
+ ax_acc.set_xticks([30, 60, 90, 120])
+ ax_acc.grid(True, linestyle="--", alpha=0.5)
+
+ ax_loss.set_title("Test Cross-Entropy Loss vs Particle Count", fontsize=11, fontweight="bold")
+ ax_loss.set_xlabel("Particle Count", fontsize=10)
+ ax_loss.set_ylabel("Test Cross-Entropy Loss", fontsize=10)
+ ax_loss.set_xticks([30, 60, 90, 120])
+ ax_loss.grid(True, linestyle="--", alpha=0.5)
+
+ ax_time.set_title("Fit Runtime vs Particle Count", fontsize=11, fontweight="bold")
+ ax_time.set_xlabel("Particle Count", fontsize=10)
+ ax_time.set_ylabel("Fit Runtime (seconds)", fontsize=10)
+ ax_time.set_xticks([30, 60, 90, 120])
+ ax_time.grid(True, linestyle="--", alpha=0.5)
+ handles, labels = ax_acc.get_legend_handles_labels()
+ if handles:
+ fig.legend(
+ handles,
+ labels,
+ loc="upper center",
+ bbox_to_anchor=(0.5, 1.02),
+ ncol=2,
+ frameon=True,
+ )
+
+ plt.tight_layout(rect=(0.0, 0.0, 1.0, 0.91))
+ fig_path2 = figure_dir / "pso_v4_particle_scaling.png"
+ plt.savefig(fig_path2, dpi=300, bbox_inches="tight")
+ plt.close(fig)
+ print(f"Rendered plot: {fig_path2}")
+
+
+def run_tuning_study(
+ phase: str = "all",
+ device_name: Optional[str] = None,
+ quick: bool = False,
+ method_filter: Optional[List[str]] = None,
+ overwrite: bool = False,
+ output_json: Path = Path("benchmark_results/pso_v4_tuning.json"),
+ result_dir: Path = Path("benchmark_results"),
+ figure_dir: Path = Path("history_plt"),
+):
+ device = resolve_execution_device(device_name)
+ print(f"Executing MNIST Tuning Study on device: {device}")
+ hw_provenance = get_hardware_provenance(device)
+
+ existing_data: Dict[str, Any] = {}
+ completed_search_runs: Dict[str, Dict[str, Any]] = {}
+ completed_confirm_runs: Dict[str, Dict[str, Any]] = {}
+ completed_scaling_runs: Dict[str, Dict[str, Any]] = {}
+
+ if output_json.exists() and not overwrite:
+ try:
+ with open(output_json, "r", encoding="utf-8") as f:
+ existing_data = json.load(f)
+ if (
+ existing_data.get("tuning_protocol_version") == TUNING_PROTOCOL_VERSION
+ and existing_data.get("quick") == quick
+ and existing_data.get("device") == str(device)
+ ):
+ for r in existing_data.get("search_runs", []):
+ if r.get("completed") and "run_id" in r:
+ completed_search_runs[r["run_id"]] = r
+ for r in existing_data.get("confirmation_runs", []):
+ if r.get("completed") and "run_id" in r:
+ completed_confirm_runs[r["run_id"]] = r
+ for r in existing_data.get("scaling_runs", []):
+ if r.get("completed") and "run_id" in r:
+ completed_scaling_runs[r["run_id"]] = r
+ print(
+ f"Loaded existing runs from {output_json}: "
+ f"{len(completed_search_runs)} search, "
+ f"{len(completed_confirm_runs)} confirmation, "
+ f"{len(completed_scaling_runs)} scaling."
+ )
+ else:
+ print("Existing JSON protocol version, quick mode, or device differs. Starting fresh.")
+ except Exception as e:
+ print(f"Warning: Failed to load existing JSON ({e}). Starting fresh.")
+
+ # Data loading and PCA preprocessing
+ x_train_raw, x_test_raw, y_train_3000, y_test_1000 = get_mnist_raw_data()
+
+ # Search inner split: Stratified 2400 train / 600 validation
+ x_inner_tr_raw, x_inner_val_raw, y_inner_tr_np, y_inner_val_np = train_test_split(
+ x_train_raw,
+ y_train_3000.numpy(),
+ train_size=2400,
+ test_size=600,
+ stratify=y_train_3000.numpy(),
+ random_state=42,
+ )
+ y_inner_tr = torch.tensor(y_inner_tr_np, dtype=torch.long)
+ y_inner_val = torch.tensor(y_inner_val_np, dtype=torch.long)
+
+ # Fit PCA32 whitening on inner train ONLY for Search phase
+ pca_search = PCA(n_components=32, whiten=True, random_state=42)
+ x_inner_tr = torch.tensor(pca_search.fit_transform(x_inner_tr_raw), dtype=torch.float32)
+ x_inner_val = torch.tensor(pca_search.transform(x_inner_val_raw), dtype=torch.float32)
+
+ # Fit PCA32 whitening on full 3000 train ONLY for Confirmation & Scaling phases
+ pca_full = PCA(n_components=32, whiten=True, random_state=42)
+ x_full_tr = torch.tensor(pca_full.fit_transform(x_train_raw), dtype=torch.float32)
+ x_full_test = torch.tensor(pca_full.transform(x_test_raw), dtype=torch.float32)
+
+ search_data_fp = compute_data_fingerprint(x_inner_tr, x_inner_val, y_inner_tr, y_inner_val)
+ full_data_fp = compute_data_fingerprint(x_full_tr, x_full_test, y_train_3000, y_test_1000)
+
+ split_fingerprints = {
+ "search_inner": search_data_fp,
+ "full": full_data_fp,
+ }
+ pca_provenance = {
+ "search": {
+ "n_samples_fit": 2400,
+ "n_samples_val": 600,
+ "n_components": 32,
+ "whiten": True,
+ "random_state": 42,
+ "explained_variance_ratio_sum": float(np.sum(pca_search.explained_variance_ratio_)),
+ },
+ "full": {
+ "n_samples_fit": 3000,
+ "n_samples_test": 1000,
+ "n_components": 32,
+ "whiten": True,
+ "random_state": 42,
+ "explained_variance_ratio_sum": float(np.sum(pca_full.explained_variance_ratio_)),
+ },
+ }
+
+ all_search_candidates = get_search_candidates()
+ if method_filter:
+ unknown_methods = sorted(set(method_filter) - set(all_search_candidates))
+ if unknown_methods:
+ raise ValueError(
+ f"Unknown tuning method(s) {unknown_methods}. "
+ f"Available: {sorted(all_search_candidates)}"
+ )
+
+ search_seeds = [51, 52, 53] if not quick else [51]
+ search_particles = 30 if not quick else 5
+ search_epochs = 80 if not quick else 5
+ batch_size = 1000 if not quick else 25
+
+ search_runs: List[Dict[str, Any]] = list(completed_search_runs.values())
+
+ # --- Phase 1: Search ---
+ if phase in ("all", "search"):
+ print("\n=== Phase 1: Search (Validation Tuning) ===")
+ for method, cand_list in all_search_candidates.items():
+ if method_filter and method not in method_filter:
+ continue
+ run_cands = cand_list[:1] if quick else cand_list
+ for cfg in run_cands:
+ for seed in search_seeds:
+ cfg_payload = {
+ "phase": "search",
+ "quick": quick,
+ "device": str(device),
+ "candidate_label": cfg.candidate_label,
+ "seed": seed,
+ "n_particles": search_particles,
+ "epochs": search_epochs,
+ "kwargs": cfg.to_optimizer_kwargs(quick=quick),
+ }
+ fp_bytes = json.dumps(cfg_payload, sort_keys=True, default=str).encode("utf-8")
+ cfg_fp = hashlib.sha256(fp_bytes).hexdigest()[:12]
+ run_id = f"search_{cfg.candidate_label}_seed{seed}_{cfg_fp}"
+
+ if run_id in completed_search_runs and not overwrite:
+ print(f"Skipping completed search run: {run_id}")
+ continue
+
+ print(f"Running {run_id} ({cfg.description})...")
+ run_res = run_single_experiment(
+ cfg=cfg,
+ seed=seed,
+ x_train=x_inner_tr,
+ y_train=y_inner_tr,
+ x_eval=x_inner_val,
+ y_eval=y_inner_val,
+ n_particles=search_particles,
+ epochs=search_epochs,
+ batch_size=batch_size,
+ device=device,
+ quick=quick,
+ eval_metric_name="val",
+ data_fp=search_data_fp,
+ run_type="search",
+ extra_meta={"run_id": run_id},
+ )
+ completed_search_runs[run_id] = run_res
+ search_runs = list(completed_search_runs.values())
+
+ _persist_json_state(
+ output_json=output_json,
+ device=device,
+ quick=quick,
+ hw_provenance=hw_provenance,
+ split_fingerprints=split_fingerprints,
+ pca_provenance=pca_provenance,
+ all_search_candidates=all_search_candidates,
+ search_runs=search_runs,
+ confirmation_runs=list(completed_confirm_runs.values()),
+ scaling_runs=list(completed_scaling_runs.values()),
+ )
+
+ # Winner Selection Logic (Requires expected completed search seeds per candidate)
+ required_seeds = 1 if quick else 3
+ winners: Dict[str, Dict[str, Any]] = {}
+ candidate_summaries: Dict[str, Dict[str, Any]] = {}
+ incomplete_methods = []
+
+ for method, cand_list in all_search_candidates.items():
+ cand_scores = []
+ for cfg in cand_list:
+ lbl = cfg.candidate_label
+ matching_runs = [r for r in search_runs if r.get("candidate_label") == lbl and r.get("completed")]
+ if len(matching_runs) < required_seeds:
+ continue
+ val_accs = [r["val_acc"] for r in matching_runs]
+ val_losses = [r["val_loss"] for r in matching_runs]
+ mean_acc = float(np.mean(val_accs))
+ mean_loss = float(np.mean(val_losses))
+ cand_scores.append({
+ "candidate_label": lbl,
+ "cfg": cfg,
+ "mean_val_loss": mean_loss,
+ "mean_val_acc": mean_acc,
+ "n_runs": len(matching_runs),
+ "stats_acc": calc_stats(val_accs),
+ "stats_loss": calc_stats(val_losses),
+ })
+ candidate_summaries[lbl] = cand_scores[-1]
+
+ if cand_scores:
+ # Rank validation accuracy descending, then validation loss ascending
+ cand_scores.sort(key=lambda c: (-c["mean_val_acc"], c["mean_val_loss"]))
+ top = cand_scores[0]
+ winners[method] = {
+ "method": method,
+ "candidate_label": top["candidate_label"],
+ "description": top["cfg"].description,
+ "mean_val_loss": top["mean_val_loss"],
+ "mean_val_acc": top["mean_val_acc"],
+ "config": top["cfg"].to_optimizer_kwargs(quick=quick),
+ "cfg": top["cfg"],
+ }
+ else:
+ incomplete_methods.append(method)
+
+ if phase in ("all", "confirmation", "scaling") and incomplete_methods:
+ raise RuntimeError(
+ f"Cannot proceed to {phase}: Search phase incomplete for method(s): {incomplete_methods}. "
+ f"Expected {required_seeds} completed search seeds per candidate."
+ )
+
+ if winners:
+ print("\n--- Search Winners Selected ---")
+ for m, w in winners.items():
+ print(f" {m:15s} -> Winner: {w['candidate_label']} (Val Acc: {w['mean_val_acc']*100:.2f}%, Val Loss: {w['mean_val_loss']:.4f})")
+
+ # --- Phase 2: Confirmation ---
+ confirm_seeds = [61, 62, 63, 64, 65] if not quick else [61]
+ confirm_particles = 30 if not quick else 5
+ confirm_epochs = 80 if not quick else 5
+ confirm_runs: List[Dict[str, Any]] = list(completed_confirm_runs.values())
+
+ if phase in ("all", "confirmation"):
+ print("\n=== Phase 2: Confirmation (Held-Out Test Confirmation) ===")
+ for method, win_info in winners.items():
+ if method_filter and method not in method_filter:
+ continue
+ cfg = win_info["cfg"]
+ for seed in confirm_seeds:
+ cfg_payload = {
+ "phase": "confirmation",
+ "quick": quick,
+ "device": str(device),
+ "candidate_label": cfg.candidate_label,
+ "seed": seed,
+ "n_particles": confirm_particles,
+ "epochs": confirm_epochs,
+ "kwargs": cfg.to_optimizer_kwargs(quick=quick),
+ }
+ fp_bytes = json.dumps(cfg_payload, sort_keys=True, default=str).encode("utf-8")
+ cfg_fp = hashlib.sha256(fp_bytes).hexdigest()[:12]
+ run_id = f"confirm_{method}_{cfg.candidate_label}_seed{seed}_{cfg_fp}"
+
+ if run_id in completed_confirm_runs and not overwrite:
+ print(f"Skipping completed confirmation run: {run_id}")
+ continue
+
+ print(f"Running confirmation {run_id} ({method} / {cfg.candidate_label})...")
+ run_res = run_single_experiment(
+ cfg=cfg,
+ seed=seed,
+ x_train=x_full_tr,
+ y_train=y_train_3000,
+ x_eval=x_full_test,
+ y_eval=y_test_1000,
+ n_particles=confirm_particles,
+ epochs=confirm_epochs,
+ batch_size=batch_size,
+ device=device,
+ quick=quick,
+ eval_metric_name="test",
+ data_fp=full_data_fp,
+ run_type="confirmation",
+ extra_meta={"run_id": run_id},
+ )
+ completed_confirm_runs[run_id] = run_res
+ confirm_runs = list(completed_confirm_runs.values())
+
+ _persist_json_state(
+ output_json=output_json,
+ device=device,
+ quick=quick,
+ hw_provenance=hw_provenance,
+ split_fingerprints=split_fingerprints,
+ pca_provenance=pca_provenance,
+ all_search_candidates=all_search_candidates,
+ search_runs=search_runs,
+ confirmation_runs=confirm_runs,
+ scaling_runs=list(completed_scaling_runs.values()),
+ )
+
+ # --- Phase 3: Particle Scaling ---
+ scaling_seeds = [71, 72, 73, 74, 75] if not quick else [71]
+ scaling_runs: List[Dict[str, Any]] = list(completed_scaling_runs.values())
+
+ if phase in ("all", "scaling"):
+ print("\n=== Phase 3: Particle Scaling Study (Adaptive Moment Winner) ===")
+ am_winner = winners.get("adaptive_moment")
+ if not am_winner:
+ raise RuntimeError("Error: No adaptive_moment search winner available for scaling study.")
+
+ cfg = am_winner["cfg"]
+ if quick:
+ scaling_configs = [
+ (5, 5, "fixed_epoch"),
+ (10, 5, "fixed_epoch"),
+ (5, 5, "fixed_budget"),
+ (10, 3, "fixed_budget"),
+ ]
+ else:
+ scaling_configs = [
+ (30, 80, "fixed_epoch"),
+ (60, 80, "fixed_epoch"),
+ (90, 80, "fixed_epoch"),
+ (120, 80, "fixed_epoch"),
+ (30, 80, "fixed_budget"),
+ (60, 40, "fixed_budget"),
+ (90, 27, "fixed_budget"),
+ (120, 20, "fixed_budget"),
+ ]
+
+ exec_cache: Dict[Tuple[int, int, int], Dict[str, Any]] = {}
+ for r in scaling_runs:
+ key = (r["n_particles"], r["epochs"], r["seed"])
+ exec_cache[key] = r
+
+ for (p_count, ep_count, regimen) in scaling_configs:
+ for seed in scaling_seeds:
+ exec_key = (p_count, ep_count, seed)
+ cfg_payload = {
+ "phase": "scaling",
+ "quick": quick,
+ "device": str(device),
+ "candidate_label": cfg.candidate_label,
+ "regimen": regimen,
+ "seed": seed,
+ "n_particles": p_count,
+ "epochs": ep_count,
+ "kwargs": cfg.to_optimizer_kwargs(quick=quick),
+ }
+ fp_bytes = json.dumps(cfg_payload, sort_keys=True, default=str).encode("utf-8")
+ cfg_fp = hashlib.sha256(fp_bytes).hexdigest()[:12]
+ run_id = f"scaling_{p_count}p_{ep_count}e_{regimen}_seed{seed}_{cfg_fp}"
+
+ if run_id in completed_scaling_runs and not overwrite:
+ print(f"Skipping completed scaling run: {run_id}")
+ continue
+
+ if exec_key in exec_cache:
+ print(f"Reusing deduplicated run for {run_id} ({p_count} particles, {ep_count} epochs, seed {seed})...")
+ existing_res = dict(exec_cache[exec_key])
+ existing_res["run_id"] = run_id
+ existing_res["regimen"] = regimen
+ run_res = existing_res
+ else:
+ print(f"Running scaling {run_id} ({p_count} particles, {ep_count} epochs, {regimen}, seed {seed})...")
+ run_res = run_single_experiment(
+ cfg=cfg,
+ seed=seed,
+ x_train=x_full_tr,
+ y_train=y_train_3000,
+ x_eval=x_full_test,
+ y_eval=y_test_1000,
+ n_particles=p_count,
+ epochs=ep_count,
+ batch_size=batch_size,
+ device=device,
+ quick=quick,
+ eval_metric_name="test",
+ data_fp=full_data_fp,
+ run_type="scaling",
+ extra_meta={"run_id": run_id, "regimen": regimen},
+ )
+ exec_cache[exec_key] = run_res
+
+ completed_scaling_runs[run_id] = run_res
+ scaling_runs = list(completed_scaling_runs.values())
+
+ _persist_json_state(
+ output_json=output_json,
+ device=device,
+ quick=quick,
+ hw_provenance=hw_provenance,
+ split_fingerprints=split_fingerprints,
+ pca_provenance=pca_provenance,
+ all_search_candidates=all_search_candidates,
+ search_runs=search_runs,
+ confirmation_runs=confirm_runs,
+ scaling_runs=scaling_runs,
+ )
+
+ write_tuning_csvs(search_runs, confirm_runs, scaling_runs, result_dir)
+
+ if phase in ("all", "plots"):
+ render_tuning_plots(search_runs, confirm_runs, scaling_runs, winners, figure_dir)
+
+ print("\nMNIST Tuning Study Complete!")
+ print(f"- Primary JSON: {output_json}")
+ print(f"- Search CSV: {result_dir / 'pso_v4_tuning_search.csv'}")
+ print(f"- Confirmation CSV: {result_dir / 'pso_v4_tuning_confirmation.csv'}")
+ print(f"- Scaling CSV: {result_dir / 'pso_v4_particle_scaling.csv'}")
+ print(f"- Figures in: {figure_dir}")
+
+
+def main():
+ parser = argparse.ArgumentParser(description="MNIST PSO Tuning & Particle Scaling Study Suite")
+ parser.add_argument(
+ "--phase",
+ choices=["all", "search", "confirmation", "scaling", "plots"],
+ default="all",
+ help="Study phase to execute (default: all)",
+ )
+ parser.add_argument(
+ "--device",
+ type=str,
+ default=None,
+ help="Execution device ('mps', 'cuda', 'cpu')",
+ )
+ parser.add_argument(
+ "--quick",
+ action="store_true",
+ help="Run reduced quick smoke test across all phases",
+ )
+ parser.add_argument(
+ "--overwrite",
+ action="store_true",
+ help="Overwrite existing completed run checkpoints and JSON results",
+ )
+ parser.add_argument(
+ "--methods",
+ type=str,
+ default=None,
+ help="Comma-separated method filter for search/confirmation reruns",
+ )
+ parser.add_argument(
+ "--output-json",
+ type=Path,
+ default=Path("benchmark_results/pso_v4_tuning.json"),
+ help="Path to output JSON result file",
+ )
+ parser.add_argument(
+ "--result-dir",
+ type=Path,
+ default=Path("benchmark_results"),
+ help="Directory to save CSV report artifacts",
+ )
+ parser.add_argument(
+ "--figure-dir",
+ type=Path,
+ default=Path("history_plt"),
+ help="Directory to save PNG figure artifacts",
+ )
+
+ args = parser.parse_args()
+ method_filter = (
+ [method.strip() for method in args.methods.split(",") if method.strip()]
+ if args.methods
+ else None
+ )
+
+ run_tuning_study(
+ phase=args.phase,
+ device_name=args.device,
+ quick=args.quick,
+ method_filter=method_filter,
+ overwrite=args.overwrite,
+ output_json=args.output_json,
+ result_dir=args.result_dir,
+ figure_dir=args.figure_dir,
+ )
+
+
+if __name__ == "__main__":
+ main()
diff --git a/test/xor.py b/test/xor.py
index 663afd9..9f06668 100644
--- a/test/xor.py
+++ b/test/xor.py
@@ -1,76 +1,89 @@
-# %%
-import os
-import sys
+import argparse
+import torch
+import torch.nn as nn
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
-
-import numpy as np
-import tensorflow as tf
-from tensorflow import keras
-from tensorflow.keras import layers
-from tensorflow.keras.layers import Dense
-from tensorflow.keras.models import Sequential
-
-from pso import optimizer
+from pso import Optimizer
+from cli import add_pso_args, build_optimizer_kwargs
def get_data():
- x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
- y = np.array([[0], [1], [1], [0]])
+ x = torch.tensor([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]], dtype=torch.float32)
+ y = torch.tensor([[0.0], [1.0], [1.0], [0.0]], dtype=torch.float32)
return x, y
-def make_model():
- model = Sequential()
- model.add(layers.Dense(2, activation="sigmoid", input_shape=(2,)))
- model.add(layers.Dense(1, activation="sigmoid"))
-
- return model
+def make_model(seed: int = 101):
+ torch.manual_seed(seed)
+ return nn.Sequential(
+ nn.Linear(2, 4),
+ nn.Tanh(),
+ nn.Linear(4, 1),
+ )
-# %%
-model = make_model()
-x_test, y_test = get_data()
+def main():
+ parser = argparse.ArgumentParser(description="PSO XOR Benchmark Script")
+ add_pso_args(
+ parser,
+ defaults={
+ "method": "original",
+ "initialization": "model_noise",
+ "evaluation": "fixed_subset",
+ "convergence": "none",
+ "refinement": "adam",
+ "n_particles": 40,
+ "c0": None,
+ "c1": None,
+ "w_min": None,
+ "w_max": None,
+ "negative_swarm": 0.1,
+ "mutation_swarm": 0.03,
+ "particle_min": -5.0,
+ "particle_max": 5.0,
+ "velocity_limit_ratio": 0.1,
+ "boundary_strategy": "reflect",
+ "initial_position_noise": 1.0,
+ "seed": 101,
+ "epochs": 120,
+ "fitness_size": 4,
+ "renewal": "loss",
+ "output_dir": "output/xor",
+ "refinement_epochs": 100,
+ "refinement_lr": 0.03,
+ },
+ )
+ args = parser.parse_args()
+ x, y = get_data()
+ model = make_model(seed=args.seed)
-loss = [
- "mean_squared_error",
- "mean_squared_logarithmic_error",
- "binary_crossentropy",
- "categorical_crossentropy",
- "sparse_categorical_crossentropy",
- "kullback_leibler_divergence",
- "poisson",
- "cosine_similarity",
- "log_cosh",
- "huber_loss",
- "mean_absolute_error",
- "mean_absolute_percentage_error",
-]
+ fitness_size = args.fitness_size if args.evaluation == "fixed_subset" else None
+ refinement_epochs = args.refinement_epochs if args.refinement == "adam" else 0
-pso_xor = optimizer(
- model,
- loss=loss[0],
- n_particles=100,
- c0=0.35,
- c1=0.8,
- w_min=0.6,
- w_max=1.2,
- negative_swarm=0.1,
- mutation_swarm=0.2,
- particle_min=-3,
- particle_max=3,
-)
-best_score = pso_xor.fit(
- x_test,
- y_test,
- epochs=200,
- save_info=True,
- log=2,
- log_name="xor",
- renewal="acc",
- check_point=25,
-)
+ kwargs = build_optimizer_kwargs(
+ args,
+ model=model,
+ loss=nn.BCEWithLogitsLoss(),
+ task="binary",
+ inertia_profile={"c0": 0.7, "c1": 0.9, "w_min": 0.3, "w_max": 0.8},
+ )
+ pso_xor = Optimizer(**kwargs)
+ print(f"Optimizer device: {pso_xor.device}")
-print("Done!")
-sys.exit(0)
-# %%
+ best_score = pso_xor.fit(
+ x,
+ y,
+ epochs=args.epochs,
+ batch_size=args.batch_size,
+ fitness_size=fitness_size,
+ renewal=args.renewal,
+ output_dir=args.output_dir,
+ save_info=True,
+ refinement_epochs=refinement_epochs,
+ refinement_lr=args.refinement_lr,
+ )
+
+ print(f"Done! Best score: {best_score}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..4d4000a
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,44 @@
+import pytest
+import torch
+import torch.nn as nn
+
+
+@pytest.fixture
+def xor_data():
+ """
+ Returns deterministic XOR input features (4, 2) and labels (4, 1) as float32 torch tensors on CPU.
+ """
+ x = torch.tensor([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]], dtype=torch.float32)
+ y = torch.tensor([[0.0], [1.0], [1.0], [0.0]], dtype=torch.float32)
+ return x, y
+
+
+@pytest.fixture
+def model_factory():
+ """
+ Factory fixture producing deterministic, PyTorch nn.Module models.
+ Supports units tuning, zero initialization, and input/output dimension changes.
+ """
+
+ def _create_model(
+ units: int = 4,
+ zero_init: bool = False,
+ input_dim: int = 2,
+ output_dim: int = 1,
+ ) -> nn.Module:
+ torch.manual_seed(42)
+ layers = [
+ nn.Linear(input_dim, units),
+ nn.ReLU(),
+ nn.Linear(units, output_dim),
+ ]
+ model = nn.Sequential(*layers)
+ if zero_init:
+ for m in model.modules():
+ if isinstance(m, nn.Linear):
+ nn.init.zeros_(m.weight)
+ if m.bias is not None:
+ nn.init.zeros_(m.bias)
+ return model
+
+ return _create_model
diff --git a/tests/test_deep_pso_methods.py b/tests/test_deep_pso_methods.py
new file mode 100644
index 0000000..d7ec4ed
--- /dev/null
+++ b/tests/test_deep_pso_methods.py
@@ -0,0 +1,235 @@
+"""
+Focused Offline Unit Tests for MNIST Deep PSO Methods (Protocol MNIST-PSO-RAW-V5 1.0.0)
+
+Tests:
+1. Split balance and nested subset inclusion invariant (I_2k subset of I_10k subset of I_50k).
+2. Latent transform exactness (z_0 = 0 -> theta_0), antithetic symmetry (even swarm pairing), and subspace dimensions.
+3. Stage transition pbest re-evaluation, gbest rebuild, and exact query/sample accounting.
+4. Validation-only pilot and elite ensemble selection with greedy disagreement.
+5. CLI argument validation.
+"""
+
+import sys
+from pathlib import Path
+
+# Insert repo test/ path so deep_pso_methods can be imported
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "test"))
+
+import math
+import numpy as np
+import pytest
+import torch
+import torch.nn as nn
+
+from deep_pso_methods import (
+ CompactCNN,
+ LatentTransform,
+ build_nested_stratified_subsets,
+ evaluate_latent_batch,
+ evaluate_probabilistic_metrics,
+ make_compact_cnn,
+ run_latent_pso,
+ select_diverse_candidates,
+ validate_cli_args,
+ build_parser,
+)
+
+
+def test_split_balance_and_nesting():
+ """Verify stratified split balance and nested index inclusion: I_2k subset of I_10k subset of I_50k."""
+ N = 50000
+ num_classes = 10
+ samples_per_class = N // num_classes
+ y_search = torch.cat([torch.full((samples_per_class,), c, dtype=torch.long) for c in range(num_classes)])
+
+ split_seed = 20260902
+ nested_subsets = build_nested_stratified_subsets(
+ y_search=y_search,
+ subset_sizes=[2000, 10000, 50000],
+ subset_seed=split_seed,
+ )
+
+ idx_2k = nested_subsets[2000]
+ idx_10k = nested_subsets[10000]
+ idx_50k = nested_subsets[50000]
+
+ assert len(idx_2k) == 2000
+ assert len(idx_10k) == 10000
+ assert len(idx_50k) == 50000
+
+ set_2k = set(idx_2k.numpy().tolist())
+ set_10k = set(idx_10k.numpy().tolist())
+ set_50k = set(idx_50k.numpy().tolist())
+
+ # Strict nesting: I_2k subset of I_10k subset of I_50k
+ assert set_2k.issubset(set_10k), "I_2k must be a strict subset of I_10k"
+ assert set_10k.issubset(set_50k), "I_10k must be a strict subset of I_50k"
+
+ # Exact stratification (equal counts per class)
+ y_2k = y_search[idx_2k].numpy()
+ y_10k = y_search[idx_10k].numpy()
+
+ counts_2k = np.bincount(y_2k, minlength=10)
+ counts_10k = np.bincount(y_10k, minlength=10)
+
+ for c in range(num_classes):
+ assert counts_2k[c] == 200, f"Class {c} in 2k subset must have 200 samples; got {counts_2k[c]}"
+ assert counts_10k[c] == 1000, f"Class {c} in 10k subset must have 1000 samples; got {counts_10k[c]}"
+
+
+def test_latent_transform_exactness_and_antithetic_symmetry():
+ """Verify transform exactness (z_0 = 0 -> theta_0), even swarm pairing, zero centroid, and subspace shapes."""
+ device = torch.device("cpu")
+ base_model = make_compact_cnn(seed=41).to(device)
+ base_vec = torch.cat([p.detach().view(-1) for p in base_model.parameters()])
+
+ dims = [290, 1024, 4096, "full"]
+ swarm_size = 30 # Even swarm size
+
+ for d in dims:
+ transform = LatentTransform(base_model, latent_dim=d, device=device)
+ Z = transform.init_swarm(swarm_size=swarm_size, seed=91)
+
+ # 1. Particle 0 is exact zero (base model)
+ decoded_p0 = transform.decode(Z[0:1]).squeeze(0)
+ assert torch.allclose(decoded_p0, base_vec, atol=1e-6), f"Particle 0 for dim={d} must match exact base vector"
+
+ # 2. For even N=30: particle N-1 (index 29) is also exact zero
+ decoded_plast = transform.decode(Z[29:30]).squeeze(0)
+ assert torch.allclose(decoded_plast, base_vec, atol=1e-6), f"Particle N-1 for dim={d} must match exact zero"
+
+ # 3. Antithetic pairs (particles 1..28 in 14 exact pairs)
+ z1 = Z[1:2]
+ z2 = Z[2:3]
+ assert torch.allclose(z1 + z2, torch.zeros_like(z1), atol=1e-6), "Antithetic pair latent sum must be zero"
+
+ delta1 = transform.decode(z1).squeeze(0) - transform.base_vec
+ delta2 = transform.decode(z2).squeeze(0) - transform.base_vec
+ assert torch.allclose(delta1 + delta2, torch.zeros_like(delta1), atol=1e-5), "Antithetic pair delta sum must be zero"
+
+ # 4. Latent swarm centroid is strictly zero
+ centroid_z = Z.mean(dim=0)
+ assert torch.allclose(centroid_z, torch.zeros_like(centroid_z), atol=1e-6), "Overall swarm centroid must be zero"
+
+
+def test_transition_reevaluation_and_exact_accounting():
+ """Verify objective size transition re-evaluates all pbests, rebuilds gbest, and asserts exact query/sample counts."""
+ device = torch.device("cpu")
+ base_model = make_compact_cnn(seed=41).to(device)
+
+ N_samples = 100
+ x_synth = torch.randn(N_samples, 1, 28, 28)
+ y_synth = torch.randint(0, 10, (N_samples,))
+
+ nested_subsets = {
+ 20: torch.arange(20, dtype=torch.long),
+ 50: torch.arange(50, dtype=torch.long),
+ }
+
+ transform = LatentTransform(base_model, latent_dim=290, device=device)
+
+ # Run 2-stage PSO: stage 0 (20 samples, 2 epochs), stage 1 (50 samples, 2 epochs), swarm_size = 10
+ # Stage 0: 2 * 10 = 20 queries, 20 * 20 = 400 sample evals. No transition re-eval.
+ # Stage 1 transition: 1 * 10 = 10 queries, 10 * 50 = 500 sample evals. Transition count = 10.
+ # Stage 1: 2 * 10 = 20 queries, 20 * 50 = 1000 sample evals.
+ # Total queries = 20 + 10 + 20 = 50.
+ # Total sample evals = 400 + 500 + 1000 = 1900.
+ res = run_latent_pso(
+ transform=transform,
+ base_model=base_model,
+ x_search=x_synth,
+ y_search=y_synth,
+ nested_subsets=nested_subsets,
+ schedule_str="20:2,50:2",
+ epochs=4,
+ swarm_size=10,
+ seed=42,
+ device=device,
+ )
+
+ assert res["transition_reevaluation_counts"] == 10, f"Expected 10 transition re-evaluations; got {res['transition_reevaluation_counts']}"
+ assert res["total_queries"] == 50, f"Expected 50 total queries; got {res['total_queries']}"
+ assert res["total_sample_evaluations"] == 1900, f"Expected 1900 sample evaluations; got {res['total_sample_evaluations']}"
+ assert len(res["stage_histories"]) == 4
+
+
+def test_validation_only_elite_and_ensemble_selection():
+ """Verify validation metrics correctly rank candidates and metric routines compute expected values."""
+ N = 100
+ C = 10
+ y_val = torch.randint(0, C, (N,))
+
+ # Candidate 1: Perfect predictions
+ probs_perfect = torch.zeros((N, C), dtype=torch.float32)
+ probs_perfect[torch.arange(N), y_val] = 1.0
+
+ # Candidate 2: Random noise
+ probs_random = torch.full((N, C), 1.0 / C, dtype=torch.float32)
+
+ m1 = evaluate_probabilistic_metrics(probs_perfect, y_val)
+ m2 = evaluate_probabilistic_metrics(probs_random, y_val)
+
+ assert m1["accuracy"] == 100.0
+ assert m1["nll"] < m2["nll"]
+ assert m1["brier"] < m2["brier"]
+ assert m1["ece"] <= 0.01
+
+ candidates = [
+ {"id": "cand2", "val_loss": m2["nll"], "val_acc": m2["accuracy"]},
+ {"id": "cand1", "val_loss": m1["nll"], "val_acc": m1["accuracy"]},
+ ]
+ candidates.sort(key=lambda c: (c["val_loss"], -c["val_acc"]))
+ assert candidates[0]["id"] == "cand1"
+
+ diverse_candidates = [
+ {
+ "seed": 7,
+ "particle_idx": particle_idx,
+ "val_loss": 0.2 + 0.01 * particle_idx,
+ "val_acc": 90.0 - 0.25 * particle_idx,
+ "val_probs": torch.roll(probs_perfect, shifts=particle_idx, dims=1),
+ "latent_z": torch.full((4,), float(particle_idx)),
+ }
+ for particle_idx in range(3)
+ ]
+ selected = select_diverse_candidates(
+ diverse_candidates, max_size=3, accuracy_window=2.0
+ )
+ assert len(selected) == 3
+ assert len({
+ (candidate["seed"], candidate["particle_idx"])
+ for candidate in selected
+ }) == 3
+
+
+def test_cli_argument_validation():
+ """Verify CLI argument validation rejects invalid parameters and accepts valid settings."""
+ parser = build_parser()
+
+ # Valid args
+ valid_args = parser.parse_args([
+ "--pilot-epochs", "160",
+ "--confirmation-epochs", "600",
+ "--confirmation-schedule", "2000:420,10000:135,50000:45",
+ "--seeds", "101", "102", "103",
+ "--dimensions", "290", "1024", "4096", "full"
+ ])
+ validate_cli_args(valid_args)
+
+ # Invalid schedule sum mismatch
+ invalid_schedule = parser.parse_args([
+ "--confirmation-epochs", "600",
+ "--confirmation-schedule", "2000:400,10000:100,50000:50" # Sums to 550 != 600
+ ])
+ with pytest.raises(ValueError, match="Schedule epoch sum"):
+ validate_cli_args(invalid_schedule)
+
+ # Invalid negative seed
+ invalid_seed = parser.parse_args(["--seeds", "-1"])
+ with pytest.raises(ValueError, match="Seeds must be non-negative"):
+ validate_cli_args(invalid_seed)
+
+ # Invalid duplicate seed
+ duplicate_seed = parser.parse_args(["--seeds", "101", "101"])
+ with pytest.raises(ValueError, match="Confirmation seeds must be unique"):
+ validate_cli_args(duplicate_seed)
diff --git a/tests/test_deep_pso_v6.py b/tests/test_deep_pso_v6.py
new file mode 100644
index 0000000..0e4c858
--- /dev/null
+++ b/tests/test_deep_pso_v6.py
@@ -0,0 +1,515 @@
+"""
+Unit tests for MNIST PSO V6 Root-Cause Isolation (Phases A & B).
+
+Covers:
+1. Scale modes (per_tensor_sd, global_rms, identity)
+2. G0 decode & default movement parity with V5 full-D
+3. Exact antithetic & independent initialization invariants
+4. Deterministic projection seeds
+5. Equalized-dimension helper RMS behavior
+6. Mutation moment reset
+7. Transition full-pbest reevaluation & exact accounting
+8. Validation checkpoints state neutrality
+9. Geometry configuration table G0-G8
+10. Deterministic confirmation selection logic
+11. Guard proving Phase B loader never requests official test dataset (train=False)
+"""
+
+import math
+import sys
+from pathlib import Path
+
+import pytest
+import torch
+import torch.nn as nn
+
+# Ensure test directory and repo root are in Python path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+from deep_pso_methods import LatentTransform, make_compact_cnn
+from deep_pso_v6 import (
+ V6GeometryConfig,
+ V6LatentTransform,
+ compute_equalized_subspace_radius,
+ get_v6_geometry_table,
+ prepare_mnist_v6_data,
+ run_v6_pso,
+ run_g8_optimizer,
+ select_confirmation_configs,
+)
+
+
+class TinyModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.fc1 = nn.Linear(10, 5)
+ self.fc2 = nn.Linear(5, 2)
+ # Initialize deterministic weights
+ nn.init.constant_(self.fc1.weight, 1.0)
+ nn.init.constant_(self.fc1.bias, 0.5)
+ nn.init.constant_(self.fc2.weight, -0.5)
+ nn.init.constant_(self.fc2.bias, 0.0)
+
+ def forward(self, x):
+ return self.fc2(torch.relu(self.fc1(x)))
+
+
+# =====================================================================
+# 1. Scale Modes Test
+# =====================================================================
+
+def test_scale_modes():
+ device = torch.device("cpu")
+ model = TinyModel()
+
+ # Per-tensor SD
+ cfg_per_tensor = V6GeometryConfig(config_id="T1", scale_type="per_tensor_sd")
+ tf_per_tensor = V6LatentTransform(model, cfg_per_tensor, device)
+ assert tf_per_tensor.scale_vec.shape[0] == tf_per_tensor.total_dim
+
+ # Global RMS
+ cfg_global_rms = V6GeometryConfig(config_id="T2", scale_type="global_rms")
+ tf_global_rms = V6LatentTransform(model, cfg_global_rms, device)
+ expected_rms = max(float(torch.sqrt(torch.mean(tf_global_rms.base_vec ** 2))), 1e-4)
+ assert torch.allclose(tf_global_rms.scale_vec, torch.full_like(tf_global_rms.scale_vec, expected_rms))
+
+ # Identity
+ cfg_identity = V6GeometryConfig(config_id="T3", scale_type="identity")
+ tf_identity = V6LatentTransform(model, cfg_identity, device)
+ assert torch.allclose(tf_identity.scale_vec, torch.ones_like(tf_identity.scale_vec))
+
+
+# =====================================================================
+# 2. G0 Decode & Default Parity with V5 Full-D
+# =====================================================================
+
+def test_G0_decode_default_parity():
+ device = torch.device("cpu")
+
+ base_v5 = make_compact_cnn(seed=41).to(device)
+ base_v6 = make_compact_cnn(seed=41).to(device)
+
+ tf_v5 = LatentTransform(base_v5, latent_dim="full", device=device)
+
+ cfg_g0 = get_v6_geometry_table()["G0"]
+ tf_v6 = V6LatentTransform(base_v6, cfg_g0, device=device)
+
+ # Verify scale_vec equality
+ assert torch.allclose(tf_v5.scale_vec, tf_v6.scale_vec, atol=1e-6)
+ assert torch.allclose(tf_v5.base_vec, tf_v6.base_vec, atol=1e-6)
+
+ # Initial swarm parity with seed 91
+ swarm_size = 30
+ seed = 91
+ Z_v5 = tf_v5.init_swarm(swarm_size=swarm_size, seed=seed)
+ Z_v6 = tf_v6.init_swarm(swarm_size=swarm_size, seed=seed)
+
+ assert torch.allclose(Z_v5, Z_v6, atol=1e-6)
+
+ # Decode parity
+ theta_v5 = tf_v5.decode(Z_v5)
+ theta_v6 = tf_v6.decode(Z_v6)
+ assert torch.allclose(theta_v5, theta_v6, atol=1e-6)
+
+ # Single movement step parity
+ c0 = c1 = 1.49618
+ w = 0.7298
+ latent_dim = tf_v6.latent_dim
+
+ V_v5 = torch.zeros((swarm_size, latent_dim), dtype=torch.float32, device=device)
+ V_v6 = torch.zeros((swarm_size, latent_dim), dtype=torch.float32, device=device)
+
+ P_v5 = Z_v5.clone()
+ P_v6 = Z_v6.clone()
+
+ gbest_z_v5 = Z_v5[0].clone()
+ gbest_z_v6 = Z_v6[0].clone()
+
+ move_rng_v5 = torch.Generator(device=device)
+ move_rng_v5.manual_seed(seed)
+
+ move_rng_v6 = torch.Generator(device=device)
+ move_rng_v6.manual_seed(seed)
+
+ r1_v5 = torch.rand((swarm_size, latent_dim), generator=move_rng_v5, device=device)
+ r2_v5 = torch.rand((swarm_size, latent_dim), generator=move_rng_v5, device=device)
+
+ r1_v6 = torch.rand((swarm_size, latent_dim), generator=move_rng_v6, device=device)
+ r2_v6 = torch.rand((swarm_size, latent_dim), generator=move_rng_v6, device=device)
+
+ assert torch.allclose(r1_v5, r1_v6)
+ assert torch.allclose(r2_v5, r2_v6)
+
+ V_raw_v5 = w * V_v5 + c0 * r1_v5 * (P_v5 - Z_v5) + c1 * r2_v5 * (gbest_z_v5.unsqueeze(0) - Z_v5)
+ V_raw_v6 = w * V_v6 + c0 * r1_v6 * (P_v6 - Z_v6) + c1 * r2_v6 * (gbest_z_v6.unsqueeze(0) - Z_v6)
+
+ assert torch.allclose(V_raw_v5, V_raw_v6, atol=1e-6)
+
+
+# =====================================================================
+# 3. Exact Antithetic & Independent Initialization Invariants
+# =====================================================================
+
+def test_exact_independent_init_invariants():
+ device = torch.device("cpu")
+ model = TinyModel()
+ swarm_size = 30
+ seed = 123
+
+ # 1. Antithetic mode
+ cfg_anti = V6GeometryConfig(config_id="T_anti", init_position_mode="antithetic", position_radius=0.5)
+ tf_anti = V6LatentTransform(model, cfg_anti, device)
+ Z_anti = tf_anti.init_swarm(swarm_size=swarm_size, seed=seed)
+
+ # Particle 0 is exact zero
+ assert torch.norm(Z_anti[0]).item() == 0.0
+
+ # For even swarm_size=30, particles 1..28 form exact pairs: (1, 2), (3, 4), ..., (27, 28)
+ for idx in range(1, 28, 2):
+ assert torch.allclose(Z_anti[idx], -Z_anti[idx + 1], atol=1e-6)
+
+ # Particle 29 is zero filler
+ assert torch.norm(Z_anti[29]).item() == 0.0
+
+ # 2. Independent mode
+ cfg_indep = V6GeometryConfig(config_id="T_indep", init_position_mode="independent", position_radius=0.5)
+ tf_indep = V6LatentTransform(model, cfg_indep, device)
+ Z_indep = tf_indep.init_swarm(swarm_size=swarm_size, seed=seed)
+
+ # Particle 0 is exact zero
+ assert torch.norm(Z_indep[0]).item() == 0.0
+
+ # Particles 1..29 are non-zero and independent
+ assert torch.norm(Z_indep[1]).item() > 0.0
+ assert not torch.allclose(Z_indep[1], -Z_indep[2])
+
+
+# =====================================================================
+# 4. Deterministic Projection Seeds Test
+# =====================================================================
+
+def test_deterministic_projection_seeds():
+ device = torch.device("cpu")
+ model = TinyModel()
+
+ cfg1 = V6GeometryConfig(config_id="P1", latent_dim=8, projection_seed=42)
+ cfg2 = V6GeometryConfig(config_id="P2", latent_dim=8, projection_seed=42)
+ cfg3 = V6GeometryConfig(config_id="P3", latent_dim=8, projection_seed=99)
+
+ tf1 = V6LatentTransform(model, cfg1, device)
+ tf2 = V6LatentTransform(model, cfg2, device)
+ tf3 = V6LatentTransform(model, cfg3, device)
+
+ # Same seed yields identical mapping
+ assert torch.equal(tf1.k_indices, tf2.k_indices)
+ assert torch.equal(tf1.weights, tf2.weights)
+
+ # Different seed yields different mapping
+ assert not torch.equal(tf1.k_indices, tf3.k_indices) or not torch.equal(tf1.weights, tf3.weights)
+
+
+# =====================================================================
+# 5. Equalized-Dimension Helper RMS Behavior Test
+# =====================================================================
+
+def test_equalized_dimension_helper_rms_behavior():
+ r_290 = compute_equalized_subspace_radius(latent_dim=290, total_dim=9098, base_radius=0.5)
+ r_1024 = compute_equalized_subspace_radius(latent_dim=1024, total_dim=9098, base_radius=0.5)
+ r_4096 = compute_equalized_subspace_radius(latent_dim=4096, total_dim=9098, base_radius=0.5)
+ r_full = compute_equalized_subspace_radius(latent_dim=9098, total_dim=9098, base_radius=0.5)
+
+ assert r_290 == pytest.approx(0.5 * math.sqrt(9098 / 290), rel=1e-5)
+ assert r_1024 == pytest.approx(0.5 * math.sqrt(9098 / 1024), rel=1e-5)
+ assert r_4096 == pytest.approx(0.5 * math.sqrt(9098 / 4096), rel=1e-5)
+ assert r_full == 0.5
+
+ # Radii decrease monotonically as latent dimension increases toward full-D
+ assert r_290 > r_1024 > r_4096 > r_full
+
+
+# =====================================================================
+# 6. Mutation Moment Reset Test
+# =====================================================================
+
+def test_mutation_moment_reset():
+ device = torch.device("cpu")
+ model = TinyModel()
+
+ x_search = torch.randn(20, 10)
+ y_search = torch.randint(0, 2, (20,))
+ x_val = torch.randn(10, 10)
+ y_val = torch.randint(0, 2, (10,))
+ nested_subsets = {10: torch.arange(10), 20: torch.arange(20)}
+
+ # Always-on mutation: mutation_prob = 1.0
+ cfg = V6GeometryConfig(
+ config_id="M1",
+ mutation_prob=1.0,
+ reset_velocity_radius=0.02,
+ )
+ transform = V6LatentTransform(model, cfg, device)
+
+ res = run_v6_pso(
+ transform=transform,
+ base_model=model,
+ x_search=x_search,
+ y_search=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ nested_subsets=nested_subsets,
+ schedule_str="10:2",
+ epochs=2,
+ swarm_size=5,
+ seed=42,
+ device=device,
+ geom_config=cfg,
+ )
+
+ assert res["config_id"] == "M1"
+ assert res["total_queries"] == 5 * 2
+ assert res["mutation_events"] == 5 * 2
+ assert res["final_moment_steps"] == [1] * 5
+
+
+# =====================================================================
+# 7. Transition Reevaluation & Exact Accounting Test
+# =====================================================================
+
+def test_transition_full_pbest_reevaluation_plus_exact_accounting():
+ device = torch.device("cpu")
+ model = TinyModel()
+
+ x_search = torch.randn(50, 10)
+ y_search = torch.randint(0, 2, (50,))
+ x_val = torch.randn(10, 10)
+ y_val = torch.randint(0, 2, (10,))
+
+ nested_subsets = {
+ 5: torch.arange(5),
+ 20: torch.arange(20),
+ }
+
+ cfg = get_v6_geometry_table()["G0"]
+ transform = V6LatentTransform(model, cfg, device)
+
+ # Run 2-stage schedule: 5 samples for 2 epochs, then 20 samples for 2 epochs
+ res = run_v6_pso(
+ transform=transform,
+ base_model=model,
+ x_search=x_search,
+ y_search=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ nested_subsets=nested_subsets,
+ schedule_str="5:2,20:2",
+ epochs=4,
+ swarm_size=10,
+ seed=42,
+ device=device,
+ geom_config=cfg,
+ transition_reset_policy="reset_vm",
+ )
+
+ # Exact query accounting:
+ # Stage 0: 10 particles x 2 epochs = 20 queries
+ # Transition: 10 particles reevaluated on new subset = 10 queries
+ # Stage 1: 10 particles x 2 epochs = 20 queries
+ # Total queries = 50
+ assert res["total_queries"] == 50
+ assert res["transition_reevaluation_counts"] == 10
+
+ # Sample evaluations:
+ # Stage 0: 20 queries x 5 samples = 100
+ # Transition: 10 queries x 20 samples = 200
+ # Stage 1: 20 queries x 20 samples = 400
+ # Total sample evals = 700
+ assert res["total_sample_evaluations"] == 700
+ assert res["final_moment_steps"] == [2] * 10
+
+
+# =====================================================================
+# 8. Validation Checkpoints State Neutrality Test
+# =====================================================================
+
+def test_validation_checkpoints_state_neutral():
+ device = torch.device("cpu")
+ model = TinyModel()
+
+ x_search = torch.randn(20, 10)
+ y_search = torch.randint(0, 2, (20,))
+ x_val = torch.randn(10, 10)
+ y_val = torch.randint(0, 2, (10,))
+ nested_subsets = {20: torch.arange(20)}
+
+ cfg = get_v6_geometry_table()["G0"]
+
+ # Run with validation checkpoints every epoch (val_check_interval=1)
+ tf1 = V6LatentTransform(model, cfg, device)
+ res_chk = run_v6_pso(
+ transform=tf1,
+ base_model=model,
+ x_search=x_search,
+ y_search=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ nested_subsets=nested_subsets,
+ schedule_str="20:5",
+ epochs=5,
+ swarm_size=6,
+ seed=99,
+ device=device,
+ geom_config=cfg,
+ val_check_interval=1,
+ )
+
+ # Run without intermediate validation checkpoints (val_check_interval=0)
+ tf2 = V6LatentTransform(model, cfg, device)
+ res_nochk = run_v6_pso(
+ transform=tf2,
+ base_model=model,
+ x_search=x_search,
+ y_search=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ nested_subsets=nested_subsets,
+ schedule_str="20:5",
+ epochs=5,
+ swarm_size=6,
+ seed=99,
+ device=device,
+ geom_config=cfg,
+ val_check_interval=0,
+ )
+
+ # Final gbest positions, loss, and training accuracy must be IDENTICAL
+ assert torch.allclose(res_chk["gbest_z"], res_nochk["gbest_z"], atol=1e-6)
+ assert res_chk["gbest_loss"] == res_nochk["gbest_loss"]
+ assert res_chk["gbest_acc"] == res_nochk["gbest_acc"]
+
+
+# =====================================================================
+# 9. Configuration Table G0-G8 Test
+# =====================================================================
+
+def test_configuration_table_G0_G8():
+ table = get_v6_geometry_table()
+ assert len(table) == 9
+ for i in range(9):
+ cid = f"G{i}"
+ assert cid in table
+ assert table[cid].config_id == cid
+
+ assert table["G0"].scale_type == "per_tensor_sd"
+ assert table["G0"].init_position_mode == "antithetic"
+ assert table["G0"].initial_velocity_radius == 0.0
+
+ assert table["G1"].scale_type == "global_rms"
+
+ assert table["G2"].initial_velocity_radius == 0.5
+
+ assert table["G3"].mutation_prob == 0.02
+
+ assert table["G5"].reflective_bound == 6.0
+
+ assert table["G6"].position_radius == 1.5
+
+ assert table["G7"].init_position_mode == "independent"
+
+ assert table["G8"].scale_type == "optimizer_default"
+
+
+# =====================================================================
+# 10. Deterministic Confirmation Selection Test
+# =====================================================================
+
+def test_deterministic_confirmation_selection():
+ mock_screen = {
+ "G0": {"val_selected_loss": 0.70, "val_selected_acc": 78.0},
+ "G1": {"val_selected_loss": 0.65, "val_selected_acc": 80.0},
+ "G2": {"val_selected_loss": 0.60, "val_selected_acc": 82.0},
+ "G3": {"val_selected_loss": 0.58, "val_selected_acc": 83.0}, # Top 1 eligible
+ "G4": {"val_selected_loss": 0.55, "val_selected_acc": 84.0}, # Top 0 eligible (best)
+ "G5": {"val_selected_loss": 0.62, "val_selected_acc": 81.0},
+ "G6": {"val_selected_loss": 0.64, "val_selected_acc": 80.5},
+ "G7": {"val_selected_loss": 0.61, "val_selected_acc": 81.5},
+ "G8": {"val_selected_loss": 0.48, "val_selected_acc": 85.0},
+ }
+
+ selected = select_confirmation_configs(mock_screen)
+ assert len(selected) == 5
+ assert selected[:3] == ["G0", "G1", "G8"]
+ assert set(selected[3:]) == {"G4", "G3"}
+
+
+# =====================================================================
+# 11. Guard: Loader Never Requests Official Test Dataset (train=False)
+# =====================================================================
+
+def test_guard_loader_never_requests_official_test_dataset(monkeypatch):
+ import torchvision.datasets
+
+ called_train_flags = []
+
+ original_mnist_init = torchvision.datasets.MNIST.__init__
+
+ def mock_mnist_init(self, root, train=True, transform=None, target_transform=None, download=False):
+ called_train_flags.append(train)
+ if not train:
+ raise AssertionError("CRITICAL VIOLATION: MNIST(train=False) requested during Phase B data loader!")
+ # Perform mock initialization with synthetic data
+ self.data = torch.randint(0, 256, (60000, 28, 28), dtype=torch.uint8)
+ self.targets = torch.randint(0, 10, (60000,), dtype=torch.long)
+
+ monkeypatch.setattr(torchvision.datasets.MNIST, "__init__", mock_mnist_init)
+
+ x_search, y_search, x_val, y_val, nested_subsets, data_fp, provenance = prepare_mnist_v6_data()
+
+ assert len(called_train_flags) > 0
+ assert all(flag is True for flag in called_train_flags)
+ assert provenance["official_test_evaluations"] == 0
+ assert provenance["test_samples"] == 0
+ assert x_search.shape == (50000, 1, 28, 28)
+ assert x_val.shape == (10000, 1, 28, 28)
+
+
+def test_g8_uses_exact_supplied_objective(monkeypatch):
+ torch.manual_seed(7)
+ device = torch.device("cpu")
+ model = TinyModel()
+ x_search = torch.randn(12, 10)
+ y_search = torch.randint(0, 2, (12,))
+ x_val = torch.randn(8, 10)
+ y_val = torch.randint(0, 2, (8,))
+ from pso.optimizer import Optimizer
+
+ fit_args = {}
+ original_fit = Optimizer.fit
+
+ def recording_fit(self, *args, **kwargs):
+ fit_args.update(kwargs)
+ return original_fit(self, *args, **kwargs)
+
+ monkeypatch.setattr(Optimizer, "fit", recording_fit)
+
+ result = run_g8_optimizer(
+ base_model=model,
+ x_2k=x_search,
+ y_2k=y_search,
+ x_val=x_val,
+ y_val=y_val,
+ epochs=2,
+ swarm_size=4,
+ seed=11,
+ device=device,
+ )
+
+ assert result["total_queries"] == 8
+ assert result["total_sample_evaluations"] == 8 * len(y_search)
+ assert result["validation_evaluations"] == 5
+ assert result["official_test_evaluations"] == 0
+ assert fit_args["renewal"] == "loss"
diff --git a/tests/test_evaluate_post_training_ensemble.py b/tests/test_evaluate_post_training_ensemble.py
new file mode 100644
index 0000000..8976f5c
--- /dev/null
+++ b/tests/test_evaluate_post_training_ensemble.py
@@ -0,0 +1,484 @@
+"""
+Unit tests for Strict Evaluator of Post-Training PSO Ensemble Study.
+
+Covers:
+1. Evaluator version and constant exports.
+2. Complete valid study artifact evaluation (pass=True, 0 failed hard gates, valid score).
+3. Schema tampering (non-dict, missing top-level keys, missing workloads).
+4. Config tampering (wrong split seed, sample counts, pool seeds, PSO parameters).
+5. Non-finite value scan (NaN or Inf values in nested metrics or weights).
+6. Simplex weight validation failure (non-unit sum, negative elements).
+7. Query and sample accounting mismatch.
+8. Base-model forward count gate failure.
+9. Data leakage contradictions, frozen-policy drift, and post-test tuning.
+10. Duplicate or missing frozen swarm seeds.
+11. SLSQP gap, uniform ensemble accuracy/NLL regression, and baseline NLL gates.
+12. Per-workload wall-time ratio gate enforcement.
+13. Missing-confirmation failure and evaluator CLI output.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+# Ensure test directory and repo root are in sys.path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+import pytest
+
+from evaluate_post_training_ensemble import (
+ EVALUATOR_VERSION,
+ EXPECTED_DATASETS,
+ EXPECTED_SPLIT_SEED,
+ evaluate_artifact,
+ main,
+ save_json_atomic,
+)
+
+
+def make_valid_metrics(nll: float = 0.35, accuracy: float = 90.0):
+ return {
+ "accuracy": accuracy,
+ "nll": nll,
+ "brier": 0.15,
+ "ece": 0.02,
+ "margin": 0.5,
+ }
+
+
+def make_valid_method(
+ nll: float = 0.35,
+ accuracy: float = 90.0,
+ weights: list = None,
+ method_type: str = "base",
+):
+ if weights is None:
+ weights = [0.2, 0.2, 0.2, 0.2, 0.2]
+
+ metrics = make_valid_metrics(nll, accuracy)
+
+ if method_type == "pso":
+ return {
+ "selected_seed": 301,
+ "selected_weights": weights,
+ "weights": weights,
+ "metrics": metrics,
+ "queries_per_seed": 900,
+ "sample_evaluations_per_seed": 9000000,
+ "median_one_seed_wall_time_seconds": 2.0,
+ "total_wall_time_seconds": 6.0,
+ "per_seed_runs": [
+ {
+ "seed": 301,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "wall_time_seconds": 2.0,
+ "metrics": metrics,
+ "weights": weights,
+ },
+ {
+ "seed": 302,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "wall_time_seconds": 2.0,
+ "metrics": make_valid_metrics(nll + 0.01, accuracy),
+ "weights": weights,
+ },
+ {
+ "seed": 303,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "wall_time_seconds": 2.0,
+ "metrics": make_valid_metrics(nll + 0.02, accuracy),
+ "weights": weights,
+ },
+ ],
+ }
+ elif method_type == "slsqp":
+ return {
+ "weights": weights,
+ "success": True,
+ "wall_time_seconds": 0.5,
+ "metrics": metrics,
+ }
+ elif method_type == "temp":
+ return {
+ "weights": weights,
+ "fitted_temperature": 1.0,
+ "metrics": metrics,
+ }
+
+ return metrics
+
+
+def make_valid_workload_entry():
+ return {
+ "provenance": {"dataset_name": "mnist", "split_seed": EXPECTED_SPLIT_SEED},
+ "training": {
+ "adam_pool_model_epochs": 50,
+ "adam_pool_wall_time_seconds": 100.0,
+ "equal_budget_50e_single_wall_time_seconds": 25.0,
+ },
+ "validation_cache": {
+ "pool_forward_passes": 5,
+ "long_single_forward_passes": 1,
+ "base_cnn_forward_passes_during_optimization": 0,
+ "size_bytes": 2000000,
+ },
+ "validation": {
+ "methods": {
+ "reference_single_10e": make_valid_method(nll=0.50, accuracy=85.0, method_type="base"),
+ "best_single_10e": make_valid_method(nll=0.45, accuracy=87.0, method_type="base"),
+ "single_50e": make_valid_method(nll=0.40, accuracy=89.0, method_type="base"),
+ "uniform_ensemble": make_valid_method(nll=0.36, accuracy=89.9, method_type="base"),
+ "uniform_temperature": make_valid_method(nll=0.355, accuracy=90.0, method_type="temp"),
+ "slsqp_weights": make_valid_method(nll=0.35, accuracy=90.0, method_type="slsqp"),
+ "pso_weights": make_valid_method(nll=0.35, accuracy=90.0, method_type="pso"),
+ }
+ },
+ "official_test_data_loaded_before_freeze": False,
+ "official_test_evaluations_before_freeze": 0,
+ "confirmation": {
+ "test_cache_counts": {
+ "dataset_loads": 1,
+ "pool_forward_passes": 5,
+ "long_single_forward_passes": 1,
+ },
+ "frozen_methods": {
+ "selected_pso_seed": 301,
+ "selected_pso_weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ "slsqp_weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ "fitted_temperature": 1.0,
+ },
+ "methods": {
+ "reference_single_10e": make_valid_metrics(nll=0.52, accuracy=84.5),
+ "best_single_10e": make_valid_metrics(nll=0.47, accuracy=86.5),
+ "single_50e": make_valid_metrics(nll=0.42, accuracy=88.5),
+ "uniform_ensemble": make_valid_metrics(nll=0.37, accuracy=89.5),
+ "uniform_temperature": make_valid_metrics(nll=0.365, accuracy=89.6),
+ "slsqp_weights": make_valid_metrics(nll=0.36, accuracy=89.7),
+ "pso_weights": make_valid_metrics(nll=0.36, accuracy=89.7),
+ },
+ },
+ }
+
+
+def make_valid_study_artifact():
+ return {
+ "protocol_version": "POST-TRAINING-PSO-ENSEMBLE 1.1.0",
+ "config": {
+ "datasets": ["mnist", "fashion_mnist"],
+ "split_seed": 20260904,
+ "search_samples": 50000,
+ "validation_samples": 10000,
+ "pool_seeds": [201, 202, 203, 204, 205],
+ "reference_single_seed": 201,
+ "equal_budget_single_epochs": 50,
+ "pso": {
+ "method": "constriction",
+ "evaluation": "full",
+ "renewal": "loss",
+ "particles": 30,
+ "epochs": 30,
+ "swarm_seeds": [301, 302, 303],
+ "particle_bounds": [-4.0, 4.0],
+ "boundary_strategy": "reflect",
+ "velocity_limit_ratio": 0.1,
+ "initial_position_noise": 0.0,
+ "queries_per_seed": 900,
+ "sample_evaluations_per_seed": 9000000,
+ },
+ },
+ "development_pass": True,
+ "policy_frozen": True,
+ "official_test_data_loaded": True,
+ "official_test_data_loaded_before_freeze": False,
+ "official_test_evaluations_before_freeze": 0,
+ "post_test_tuning_or_reruns": 0,
+ "resource_totals": {
+ "total_adam_pool_model_epochs": 100,
+ "total_pso_queries": 5400,
+ "total_pso_sample_evaluations": 54000000,
+ "total_pso_wall_time_seconds": 12.0,
+ "pso_to_pool_wall_ratio": 0.02,
+ },
+ "workloads": {
+ "mnist": make_valid_workload_entry(),
+ "fashion_mnist": make_valid_workload_entry(),
+ },
+ }
+
+
+def test_evaluator_version_and_imports():
+ """Verify evaluator version identifier."""
+ assert isinstance(EVALUATOR_VERSION, str)
+ assert EVALUATOR_VERSION.startswith("POST-TRAINING-PSO-ENSEMBLE-EVALUATOR")
+
+
+def test_evaluate_artifact_valid_passing_study():
+ """Verify evaluator approves valid study artifact with zero hard gate failures."""
+ artifact = make_valid_study_artifact()
+ result = evaluate_artifact(artifact)
+
+ assert result["pass"] is True
+ assert result["development_pass"] is True
+ assert result["confirmation_pass"] is True
+ assert result["failed_hard_gate_count"] == 0
+ assert isinstance(result["score"], float)
+ assert result["score"] > -100.0
+
+
+def test_evaluate_artifact_schema_tampering():
+ """Verify evaluator rejects non-dict, missing config, and missing workload structures."""
+ # 1. Non-dict artifact
+ res_non_dict = evaluate_artifact("invalid_string_artifact")
+ assert res_non_dict["pass"] is False
+ assert res_non_dict["failed_hard_gate_count"] >= 1
+ assert "schema" in res_non_dict["issues"]
+ assert len(res_non_dict["issues"]["schema"]) > 0
+
+ # 2. Missing config
+ art_no_cfg = make_valid_study_artifact()
+ del art_no_cfg["config"]
+ res_no_cfg = evaluate_artifact(art_no_cfg)
+ assert res_no_cfg["pass"] is False
+ assert len(res_no_cfg["issues"]["schema"]) > 0
+
+ # 3. Missing dataset in workloads
+ art_missing_ds = make_valid_study_artifact()
+ del art_missing_ds["workloads"]["fashion_mnist"]
+ res_missing_ds = evaluate_artifact(art_missing_ds)
+ assert res_missing_ds["pass"] is False
+ assert len(res_missing_ds["issues"]["schema"]) > 0
+
+
+def test_evaluate_artifact_config_tampering():
+ """Verify evaluator flags mismatched split seed, sample counts, or PSO parameters."""
+ art = make_valid_study_artifact()
+ art["config"]["split_seed"] = 99999999 # Mismatched seed
+ art["config"]["pso"]["particles"] = 15 # Expected 30
+ art["config"]["pso"]["epochs"] = 15 # Expected 30
+
+ res = evaluate_artifact(art)
+ assert res["pass"] is False
+ assert len(res["issues"]["config"]) >= 2
+
+
+def test_evaluate_artifact_non_finite_tampering():
+ """Verify evaluator detects non-finite values (NaN / Inf) in nested metrics or weights."""
+ art = make_valid_study_artifact()
+ # Inject NaN into validation NLL
+ art["workloads"]["mnist"]["validation"]["methods"]["pso_weights"]["per_seed_runs"][0]["metrics"]["nll"] = float("nan")
+
+ res = evaluate_artifact(art)
+ assert res["pass"] is False
+ assert res["failed_hard_gate_count"] >= 1
+ assert len(res["issues"]["finite"]) >= 1
+
+
+def test_evaluate_artifact_simplex_weights_tampering():
+ """Verify evaluator rejects weight vectors that do not sum to 1.0 within tolerance."""
+ art = make_valid_study_artifact()
+ # Set weights that sum to 1.5
+ art["workloads"]["mnist"]["validation"]["methods"]["slsqp_weights"]["weights"] = [0.3, 0.3, 0.3, 0.3, 0.3]
+
+ res = evaluate_artifact(art)
+ assert res["pass"] is False
+ assert res["failed_hard_gate_count"] >= 1
+ assert len(res["issues"]["weights"]) >= 1
+
+
+def test_evaluate_artifact_accounting_tampering():
+ """Verify evaluator flags invalid PSO queries or sample evaluations accounting."""
+ art = make_valid_study_artifact()
+ art["config"]["pso"]["queries_per_seed"] = 899 # Expected 900
+
+ res = evaluate_artifact(art)
+ assert res["pass"] is False
+ assert len(res["issues"]["accounting"]) >= 1
+
+def test_evaluate_artifact_requires_each_frozen_swarm_seed_once():
+ """Duplicate seed records cannot stand in for independent replication."""
+ art = make_valid_study_artifact()
+ runs = art["workloads"]["mnist"]["validation"]["methods"]["pso_weights"][
+ "per_seed_runs"
+ ]
+ runs[1]["seed"] = 301
+
+ result = evaluate_artifact(art)
+
+ assert result["pass"] is False
+ assert any(
+ "each frozen seed exactly once" in issue
+ for issue in result["issues"]["config"]
+ )
+
+
+def test_evaluate_artifact_base_model_forward_count_tampering():
+ """Verify evaluator flags non-zero base model forward passes during optimization."""
+ art = make_valid_study_artifact()
+ art["workloads"]["mnist"]["validation_cache"]["base_cnn_forward_passes_during_optimization"] = 2
+
+ res = evaluate_artifact(art)
+ assert res["pass"] is False
+ assert res["failed_hard_gate_count"] >= 1
+ assert len(res["issues"]["accounting"]) >= 1
+
+
+def test_evaluate_artifact_leakage_and_post_test_tuning_tampering():
+ """Global/local leakage contradictions and post-test tuning must fail."""
+ art_loaded = make_valid_study_artifact()
+ art_loaded["official_test_data_loaded_before_freeze"] = True
+ res_loaded = evaluate_artifact(art_loaded)
+ assert res_loaded["pass"] is False
+ assert len(res_loaded["issues"]["leakage"]) >= 1
+
+ art_evals = make_valid_study_artifact()
+ art_evals["official_test_evaluations_before_freeze"] = 1
+ res_evals = evaluate_artifact(art_evals)
+ assert res_evals["pass"] is False
+ assert len(res_evals["issues"]["leakage"]) >= 1
+
+ art_tune = make_valid_study_artifact()
+ art_tune["post_test_tuning_or_reruns"] = 1
+ res_tune = evaluate_artifact(art_tune)
+ assert res_tune["pass"] is False
+ assert len(res_tune["issues"]["tuning"]) >= 1
+
+def test_evaluate_artifact_rejects_confirmation_policy_drift():
+ """Confirmation must identify the exact validation-frozen method parameters."""
+ mutations = [
+ ("policy_frozen", False),
+ (
+ "selected_pso_seed",
+ 302,
+ ),
+ (
+ "selected_pso_weights",
+ [1.0, 0.0, 0.0, 0.0, 0.0],
+ ),
+ (
+ "slsqp_weights",
+ [1.0, 0.0, 0.0, 0.0, 0.0],
+ ),
+ ("fitted_temperature", 2.0),
+ ]
+
+ for field, value in mutations:
+ art = make_valid_study_artifact()
+ if field == "policy_frozen":
+ art[field] = value
+ else:
+ art["workloads"]["mnist"]["confirmation"]["frozen_methods"][
+ field
+ ] = value
+
+ result = evaluate_artifact(art)
+
+ assert result["pass"] is False, field
+ assert result["confirmation_gates"]["frozen_policy_consistency"] is False
+
+
+def test_evaluate_artifact_slsqp_gap_and_uniform_regression_tampering():
+ """Verify evaluator flags PSO NLL gap vs SLSQP > 0.5% or accuracy regression > 0.1 pp vs uniform."""
+ # 1. SLSQP gap > 0.005
+ art_slsqp = make_valid_study_artifact()
+ # SLSQP NLL = 0.30, PSO NLL = 0.35 -> relative gap (0.35 - 0.30)/0.30 = 0.1667 > 0.005
+ art_slsqp["workloads"]["mnist"]["validation"]["methods"]["slsqp_weights"]["metrics"]["nll"] = 0.30
+ art_slsqp["workloads"]["mnist"]["validation"]["methods"]["pso_weights"]["metrics"]["nll"] = 0.35
+ art_slsqp["workloads"]["mnist"]["validation"]["methods"]["pso_weights"]["per_seed_runs"][0]["metrics"]["nll"] = 0.35
+
+ res_slsqp = evaluate_artifact(art_slsqp)
+ assert res_slsqp["pass"] is False
+ assert len(res_slsqp["issues"]["gates"]) >= 1
+
+ # 2. PSO accuracy regression > 0.1 pp below uniform
+ art_acc = make_valid_study_artifact()
+ art_acc["workloads"]["mnist"]["validation"]["methods"]["uniform_ensemble"]["accuracy"] = 90.0
+ # Set PSO accuracy to 89.5 (0.5 pp regression)
+ art_acc["workloads"]["mnist"]["validation"]["methods"]["pso_weights"]["metrics"]["accuracy"] = 89.5
+ art_acc["workloads"]["mnist"]["validation"]["methods"]["pso_weights"]["per_seed_runs"][0]["metrics"]["accuracy"] = 89.5
+
+ res_acc = evaluate_artifact(art_acc)
+ assert res_acc["pass"] is False
+ assert len(res_acc["issues"]["gates"]) >= 1
+
+
+def test_evaluate_artifact_reference_single_and_equal_budget_tampering():
+ """Verify evaluator flags PSO validation NLL >= reference single or > equal-budget single NLL + 1e-7."""
+ # PSO NLL > reference single NLL
+ art_ref = make_valid_study_artifact()
+ art_ref["workloads"]["mnist"]["validation"]["methods"]["reference_single_10e"]["nll"] = 0.30
+ art_ref["workloads"]["mnist"]["validation"]["methods"]["pso_weights"]["metrics"]["nll"] = 0.35
+ art_ref["workloads"]["mnist"]["validation"]["methods"]["pso_weights"]["per_seed_runs"][0]["metrics"]["nll"] = 0.35
+
+ res_ref = evaluate_artifact(art_ref)
+ assert res_ref["pass"] is False
+ assert len(res_ref["issues"]["gates"]) >= 1
+
+
+def test_evaluate_artifact_wall_time_ratio_tampering():
+ """Each workload's recomputed median PSO/Adam ratio must stay at most 10%."""
+ art_time = make_valid_study_artifact()
+ art_time["workloads"]["mnist"]["training"]["adam_pool_wall_time_seconds"] = 10.0
+ runs = art_time["workloads"]["mnist"]["validation"]["methods"][
+ "pso_weights"
+ ]["per_seed_runs"]
+ for run in runs:
+ run["wall_time_seconds"] = 2.0
+
+ result = evaluate_artifact(art_time)
+
+ assert result["pass"] is False
+ assert result["development_gates"][
+ "maximum_median_one_seed_pso_to_pool_training_wall_ratio"
+ ] is False
+ assert len(result["issues"]["gates"]) >= 1
+
+
+def test_evaluate_artifact_missing_confirmation_on_dev_pass():
+ """Verify missing confirmation on development pass fails overall study evaluation."""
+ art_no_conf = make_valid_study_artifact()
+ art_no_conf["official_test_data_loaded"] = False
+ art_no_conf["workloads"]["mnist"]["confirmation"] = None
+ art_no_conf["workloads"]["fashion_mnist"]["confirmation"] = None
+
+ res = evaluate_artifact(art_no_conf)
+ assert res["pass"] is False
+ assert res["confirmation_pass"] is False
+ assert len(res["issues"]["gates"]) >= 1 or len(res["issues"]["leakage"]) >= 1
+
+
+def test_evaluator_cli(tmp_path, monkeypatch):
+ """Verify CLI main entrypoint writes evaluation payload atomically."""
+ art = make_valid_study_artifact()
+ art_path = tmp_path / "study_artifact.json"
+ save_json_atomic(art, art_path)
+
+ out_path = tmp_path / "evaluation_output.json"
+
+ # Simulate command-line arguments: --artifact --output
+ test_args = [
+ "evaluate_post_training_ensemble.py",
+ "--artifact",
+ str(art_path),
+ "--output",
+ str(out_path),
+ ]
+ monkeypatch.setattr(sys, "argv", test_args)
+
+ with pytest.raises(SystemExit) as exc_info:
+ main()
+
+ assert exc_info.value.code == 0
+ assert out_path.exists()
+
+ eval_data = json.loads(out_path.read_text())
+ assert eval_data["pass"] is True
+ assert eval_data["failed_hard_gate_count"] == 0
+ assert isinstance(eval_data["score"], float)
diff --git a/tests/test_evaluate_post_training_model_convergence.py b/tests/test_evaluate_post_training_model_convergence.py
new file mode 100644
index 0000000..8dbb4ae
--- /dev/null
+++ b/tests/test_evaluate_post_training_model_convergence.py
@@ -0,0 +1,256 @@
+"""Behavioral tests for the independent model-convergence evaluator.
+
+These fixtures intentionally stay in prediction/artifact space: no dataset, model,
+optional detection dependency, or network access is needed.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import sys
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+import evaluate_post_training_model_convergence as evaluator
+
+
+CLASSIFICATION_RECORDS = [
+ {"image_id": "a", "probabilities": [0.80, 0.20], "target": 0},
+ {"image_id": "b", "probabilities": [0.40, 0.60], "target": 1},
+ {"image_id": "c", "probabilities": [0.70, 0.30], "target": 1},
+ {"image_id": "d", "probabilities": [0.55, 0.45], "target": 0},
+]
+
+
+def _secondary_classification_metrics(records):
+ brier_terms = []
+ confidences = []
+ correctness = []
+ for record in records:
+ probabilities = record["probabilities"]
+ target = record["target"]
+ brier_terms.append(
+ sum((probability - (index == target)) ** 2 for index, probability in enumerate(probabilities))
+ )
+ prediction = max(range(len(probabilities)), key=probabilities.__getitem__)
+ confidences.append(max(probabilities))
+ correctness.append(prediction == target)
+
+ # Match the protocol's 15 equal-width confidence bins, including the
+ # right-most endpoint in the final bin.
+ ece = 0.0
+ for bin_index in range(15):
+ lower, upper = bin_index / 15.0, (bin_index + 1) / 15.0
+ members = [
+ index
+ for index, confidence in enumerate(confidences)
+ if (confidence >= lower and (confidence < upper or bin_index == 14 and confidence <= upper))
+ ]
+ if members:
+ accuracy = sum(correctness[index] for index in members) / len(members)
+ confidence = sum(confidences[index] for index in members) / len(members)
+ ece += abs(accuracy - confidence) * len(members) / len(records)
+ return sum(brier_terms) / len(records), ece
+
+
+def test_classification_metrics_recompute_exact_nll_accuracy_brier_and_ece():
+ """Per-example probabilities determine all classification statistics without rounding."""
+ metrics = evaluator.classification_metrics(CLASSIFICATION_RECORDS)
+ expected_nll = -math.fsum(math.log(record["probabilities"][record["target"]]) for record in CLASSIFICATION_RECORDS) / 4
+ expected_brier, expected_ece = _secondary_classification_metrics(CLASSIFICATION_RECORDS)
+
+ assert metrics["n"] == 4
+ assert metrics["accuracy"] == pytest.approx(0.75)
+ assert metrics["nll"] == pytest.approx(expected_nll, rel=0, abs=1e-15)
+ assert metrics["brier"] == pytest.approx(expected_brier, rel=0, abs=1e-15)
+ assert metrics["ece15"] == pytest.approx(expected_ece, rel=0, abs=1e-15)
+ # The evaluator must retain the unrounded probability/target evidence used
+ # for the secondary metrics rather than substituting aggregate values.
+ assert metrics["probabilities"] == [record["probabilities"] for record in CLASSIFICATION_RECORDS]
+ assert metrics["targets"] == [record["target"] for record in CLASSIFICATION_RECORDS]
+
+
+def test_classification_metrics_reject_invalid_probability_contracts():
+ with pytest.raises(ValueError, match="sum to one"):
+ evaluator.classification_metrics([{"probabilities": [0.8, 0.3], "target": 0}])
+ with pytest.raises(ValueError, match="invalid classification"):
+ evaluator.classification_metrics([{"probabilities": [1.0, 0.0], "target": True}])
+ with pytest.raises(ZeroDivisionError):
+ evaluator.classification_metrics([])
+
+
+def test_detection_metrics_deduplicates_predictions_and_counts_empty_images():
+ """One image may have duplicate detections while other images are empty."""
+ box = [0.0, 0.0, 10.0, 10.0]
+ records = [
+ {
+ "image_id": "duplicate",
+ "ground_truth": [{"class_id": 0, "box": box}],
+ # Deliberately preserve a low-score row first: matching is one-to-one,
+ # then confidence ranking makes the duplicate a false positive.
+ "predictions": [
+ {"class_id": 0, "score": 0.10, "box": box},
+ {"class_id": 0, "score": 0.90, "box": box},
+ ],
+ },
+ {"image_id": "empty-predictions", "ground_truth": [{"class_id": 1, "box": box}], "predictions": []},
+ {"image_id": "empty-image", "ground_truth": [], "predictions": []},
+ ]
+
+ metrics = evaluator.detection_metrics(records, class_count=2)
+
+ assert metrics["n"] == 3
+ assert metrics["ground_truth"] == 2
+ assert metrics["predictions"] == 2
+ expected_ap = 0.49750000000000033
+ assert metrics["per_class_ap"]["0"] == pytest.approx(
+ [expected_ap] * 10,
+ rel=0,
+ abs=1e-12,
+ )
+ assert metrics["per_class_ap"]["1"] == pytest.approx(
+ [0.0] * 10,
+ rel=0,
+ abs=1e-12,
+ )
+ assert metrics["map50"] == pytest.approx(expected_ap / 2, abs=1e-12)
+ assert metrics["map50_95"] == pytest.approx(expected_ap / 2, abs=1e-12)
+
+
+def test_detection_metrics_empty_dataset_is_a_finite_zero_result():
+ metrics = evaluator.detection_metrics([], class_count=3)
+ assert metrics["n"] == 0
+ assert metrics["ground_truth"] == 0
+ assert metrics["predictions"] == 0
+ assert metrics["map50"] == 0.0
+ assert metrics["map50_95"] == 0.0
+ assert set(metrics["per_class_ap"]) == {"0", "1", "2"}
+ assert all(value == [0.0] * 10 for value in metrics["per_class_ap"].values())
+
+
+def test_bootstrap_helper_is_deterministic_and_uses_improvement_orientation():
+ base = [
+ {"image_id": "0", "probabilities": [0.60, 0.40], "target": 0},
+ {"image_id": "1", "probabilities": [0.40, 0.60], "target": 1},
+ {"image_id": "2", "probabilities": [0.60, 0.40], "target": 0},
+ {"image_id": "3", "probabilities": [0.40, 0.60], "target": 1},
+ ]
+ improved = [
+ {**record, "probabilities": [0.90, 0.10] if record["target"] == 0 else [0.10, 0.90]}
+ for record in base
+ ]
+ pairs = [(base, improved), (base, improved)]
+
+ first = evaluator._bootstrap_from_records(pairs, "classification")
+ second = evaluator._bootstrap_from_records(pairs, "classification")
+
+ assert first == second
+ assert first["available"] is True
+ assert first["seed"] == evaluator.BOOTSTRAP_SEED
+ assert first["resamples"] == evaluator.BOOTSTRAP_RESAMPLES
+ assert first["alpha"] == evaluator.BOOTSTRAP_ALPHA
+ assert first["statistic"] > 0.0
+ assert first["lower"] > 0.0
+ assert first["excludes_zero"] is True
+
+
+def test_bootstrap_helper_rejects_misaligned_image_identity():
+ base = [{"image_id": "a", "probabilities": [1.0, 0.0], "target": 0}]
+ reordered = [{"image_id": "b", "probabilities": [1.0, 0.0], "target": 0}]
+ result = evaluator._bootstrap_from_records([(base, reordered)], "classification")
+ assert result["available"] is False
+ assert "image IDs/order differ" in result["reason"]
+
+
+def test_global_query_and_candidate_sample_constants_are_exact():
+ expected_queries = (
+ len(evaluator.WORKLOADS)
+ * len(evaluator.BASE_SEEDS)
+ * len(evaluator.SWARM_SEEDS)
+ * evaluator.PRIMARY_QUERIES
+ + len(evaluator.WORKLOADS)
+ * len(evaluator.SWARM_SEEDS)
+ * evaluator.ENSEMBLE_QUERIES
+ )
+ expected_samples = sum(
+ (
+ len(evaluator.BASE_SEEDS) * len(evaluator.SWARM_SEEDS) * evaluator.PRIMARY_QUERIES
+ + len(evaluator.SWARM_SEEDS) * evaluator.ENSEMBLE_QUERIES
+ )
+ * evaluator.OBJECTIVE_SAMPLES[workload]
+ for workload in evaluator.WORKLOADS
+ )
+
+ assert evaluator.PRIMARY_QUERIES == 720
+ assert evaluator.ENSEMBLE_QUERIES == 240
+ assert evaluator.TOTAL_PSO_QUERIES == expected_queries == 21_600
+ assert evaluator.TOTAL_CANDIDATE_SAMPLES == expected_samples == 18_432_000
+
+
+def test_pt_prediction_artifact_is_resolved_without_model_import(tmp_path):
+ torch = pytest.importorskip("torch")
+ records = [{"image_id": "one", "probabilities": [0.25, 0.75], "target": 1}]
+ artifact = tmp_path / "predictions.pt"
+ torch.save({"predictions": records}, artifact)
+
+ resolved = evaluator._prediction_records({"prediction_artifact": "predictions.pt"}, tmp_path)
+
+ assert resolved == records
+
+
+def _write_compact_results(root: Path, *, leakage_bad: bool, malformed_matrix: bool) -> None:
+ leakage = {
+ "official_test_data_loaded_before_freeze": True if leakage_bad else False,
+ "official_test_evaluations_before_freeze": 1 if leakage_bad else 0,
+ "official_test_construction": 0 if leakage_bad else 1,
+ "official_test_forward_passes": 0 if leakage_bad else 1,
+ }
+ for workload in evaluator.WORKLOADS:
+ workload_dir = root / "workloads" / workload
+ workload_dir.mkdir(parents=True, exist_ok=True)
+ result = {
+ "workload_id": workload,
+ "family": "detection" if workload == evaluator.DETECTION_WORKLOAD else "classification",
+ "manifests": {},
+ "provenance": {},
+ "baselines": {},
+ "arms": {} if malformed_matrix else {"feature_pso": []},
+ "ensemble": {},
+ "development_selection": {},
+ "confirmation": {},
+ "integrity": {},
+ "leakage_counters": leakage,
+ "resource_ledger": {},
+ "artifact_hashes": {},
+ }
+ (workload_dir / "result.json").write_text(json.dumps(result), encoding="utf-8")
+
+
+def test_evaluate_run_rejects_incomplete_matrix_from_temp_fixture(tmp_path):
+ _write_compact_results(tmp_path, leakage_bad=False, malformed_matrix=True)
+
+ result = evaluator.evaluate_run(tmp_path)
+
+ assert result["pass"] is False
+ assert result["issue_counts"]["matrix"] >= len(evaluator.WORKLOADS)
+ assert any("missing arms" in issue for issue in result["issues"]["matrix"])
+
+
+def test_evaluate_run_rejects_pre_freeze_test_leakage_from_temp_fixture(tmp_path):
+ _write_compact_results(tmp_path, leakage_bad=True, malformed_matrix=False)
+
+ result = evaluator.evaluate_run(tmp_path)
+
+ assert result["pass"] is False
+ assert result["issue_counts"]["leakage"] >= len(evaluator.WORKLOADS)
+ assert any("must be explicitly marked not loaded" in issue for issue in result["issues"]["leakage"])
+ assert any("exposure before freeze" in issue for issue in result["issues"]["leakage"])
diff --git a/tests/test_heavy_pso_autoresearch.py b/tests/test_heavy_pso_autoresearch.py
new file mode 100644
index 0000000..4f88a0f
--- /dev/null
+++ b/tests/test_heavy_pso_autoresearch.py
@@ -0,0 +1,3049 @@
+"""
+Offline Unit Tests for Heavy Task PSO Autoresearch & Evaluator Infrastructure.
+
+Defends observable behavior, schema contracts, exact dimension/radius scaling,
+projection seed determinism, evaluator gate boundaries (including the OR gate on mnist_wide),
+config mismatches, non-finite rejection, zero-test enforcement, candidate selection preferences,
+JSON artifact safety, and synthetic CPU experiment execution.
+"""
+
+import hashlib
+import json
+import math
+import sys
+from pathlib import Path
+from typing import Dict
+
+import numpy as np
+import pytest
+import torch
+import torch.nn as nn
+
+# Ensure test directory and repo root are in Python path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+from evaluate_heavy_autoresearch import (
+ BASELINE_POLICY,
+ EVALUATOR_VERSION,
+ EXPECTED_SEEDS,
+ EXPECTED_WORKLOADS,
+ evaluate_heavy_autoresearch,
+)
+import heavy_pso_autoresearch
+from heavy_pso_autoresearch import (
+ AUTORESEARCH_PROTOCOL_VERSION,
+ DEFAULT_PROJECTION_SEED_MODE,
+ GEOMETRY_POLICIES,
+ PROJECTION_SEED_MODES,
+ PROJECTION_SCOPES,
+ TensorLocalLatentTransform,
+ BalancedGlobalLatentTransform,
+ TwoHashGlobalLatentTransform,
+ LargestTensorHashLatentTransform,
+ LargestTensorRowHashLatentTransform,
+ AdjacentPairLatentTransform,
+ AdjacentDifferenceLatentTransform,
+ allocate_tensor_latent_dims,
+ build_parser,
+ compute_core_swarm_state_bytes,
+ compute_baseline_core_swarm_state_bytes,
+ compute_latent_dim,
+ construct_equalized_geometry,
+ derive_projection_seed,
+ validate_projection_seed_config,
+ parse_projection_seed_arg,
+ validate_geometry_multiplier,
+ parse_projection_scope_arg,
+ validate_projection_scope_config,
+ get_effective_projection_scope,
+ format_ratio_id,
+ run_heavy_pso_autoresearch,
+)
+from deep_pso_v6 import V6GeometryConfig, V6LatentTransform, get_v6_geometry_table
+
+
+def _mock_prepare_heavy_task_data(dataset_name: str, split_seed: int = 20260902, cache_dir=None):
+ N_search, N_val = 20, 10
+ x_search = torch.randn(N_search, 1, 28, 28)
+ y_search = torch.randint(0, 10, (N_search,))
+ x_val = torch.randn(N_val, 1, 28, 28)
+ y_val = torch.randint(0, 10, (N_val,))
+ nested_subsets = {10: np.arange(10), 10000: np.arange(20)}
+ data_fp = hashlib.sha256(dataset_name.encode()).hexdigest()[:16]
+ provenance = {
+ "split_fingerprint": f"split_{split_seed}_{data_fp}",
+ "data_fingerprint": data_fp,
+ }
+ return x_search, y_search, x_val, y_val, nested_subsets, data_fp, provenance
+
+
+def test_exact_dimension_and_radius_scaling():
+ """Verify exact dimension rounding and sqrt(total_dim / latent_dim) radius scaling."""
+ # CompactCNN (total_dim = 9098)
+ assert compute_latent_dim(9098, 1.0) == 9098
+ assert compute_latent_dim(9098, 0.5) == 4549
+ assert compute_latent_dim(9098, 0.25) == 2275 # round(9098 * 0.25) = round(2274.5) = 2275
+ assert compute_latent_dim(9098, 0.125) == 1137
+ assert compute_latent_dim(9098, 0.03125) == 284
+
+ # WideCNN (total_dim = 55338)
+ assert compute_latent_dim(55338, 0.5) == 27669
+ assert compute_latent_dim(55338, 0.25) == 13835
+ assert compute_latent_dim(55338, 0.125) == 6917
+ assert compute_latent_dim(55338, 0.03125) == 1729
+
+ # Radius scaling test
+ geom_table = get_v6_geometry_table()
+ base_g6 = geom_table["G6"] # position=1.5, vel=0.5, reset=0.02, bound=6.0
+ total_dim = 9098
+ latent_dim = 4549
+ scale_factor = math.sqrt(total_dim / latent_dim)
+
+ eq_g6 = construct_equalized_geometry(
+ base_geom=base_g6,
+ total_dim=total_dim,
+ latent_dim=latent_dim,
+ projection_seed=42,
+ ratio_str="r0.5",
+ )
+
+ assert eq_g6.latent_dim == latent_dim
+ assert eq_g6.projection_seed == 42
+ assert math.isclose(eq_g6.position_radius, base_g6.position_radius * scale_factor)
+ assert math.isclose(eq_g6.initial_velocity_radius, base_g6.initial_velocity_radius * scale_factor)
+ assert math.isclose(eq_g6.reset_velocity_radius, base_g6.reset_velocity_radius * scale_factor)
+ assert math.isclose(eq_g6.reflective_bound, base_g6.reflective_bound * scale_factor)
+
+
+def test_deterministic_projection_seeds():
+ """Verify projection seeds are deterministic, explicit, and vary by workload, ratio, and seed."""
+ s1 = derive_projection_seed("mnist_compact", 0.5, 101)
+ s2 = derive_projection_seed("mnist_compact", 0.5, 101)
+ assert s1 == s2, "Projection seed derivation must be deterministic"
+ assert isinstance(s1, int) and 0 <= s1 < 2**31
+
+ # Variation checks
+ s_diff_wl = derive_projection_seed("mnist_wide", 0.5, 101)
+ s_diff_ratio = derive_projection_seed("mnist_compact", 0.25, 101)
+ s_diff_seed = derive_projection_seed("mnist_compact", 0.5, 102)
+
+ assert s1 != s_diff_wl, "Projection seed must vary by workload"
+ assert s1 != s_diff_ratio, "Projection seed must vary by ratio"
+ assert s1 != s_diff_seed, "Projection seed must vary by swarm seed"
+
+
+def create_mock_baseline_json(tmp_path: Path) -> Path:
+ """Helper creating a minimal valid baseline heavy tasks JSON artifact."""
+ payload = {
+ "protocol_version": "HEAVY-TASK-PSO-V6 1.0.0",
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "confirmation_results": {
+ "mnist_compact": {
+ "G8": {
+ "stats": {
+ "val_nll": {"mean": 1.50},
+ "val_acc": {"mean": 50.0},
+ "val_brier": {"mean": 0.65},
+ "val_ece": {"mean": 0.05},
+ }
+ }
+ },
+ "mnist_wide": {
+ "G5": {
+ "stats": {
+ "val_nll": {"mean": 1.70},
+ "val_acc": {"mean": 42.0},
+ "val_brier": {"mean": 0.70},
+ "val_ece": {"mean": 0.08},
+ }
+ }
+ },
+ "fashion_compact": {
+ "G8": {
+ "stats": {
+ "val_nll": {"mean": 1.60},
+ "val_acc": {"mean": 48.0},
+ "val_brier": {"mean": 0.68},
+ "val_ece": {"mean": 0.06},
+ }
+ }
+ },
+ "fashion_wide": {
+ "G5": {
+ "stats": {
+ "val_nll": {"mean": 1.75},
+ "val_acc": {"mean": 40.0},
+ "val_brier": {"mean": 0.72},
+ "val_ece": {"mean": 0.09},
+ }
+ }
+ },
+ },
+ }
+ for workload_id, method_id in BASELINE_POLICY.items():
+ entry = payload["confirmation_results"][workload_id][method_id]
+ total_dim = 9098 if "compact" in workload_id else 55338
+ baseline_bytes = compute_baseline_core_swarm_state_bytes(
+ workload_id,
+ particles=12,
+ total_dim=total_dim,
+ )
+ entry["per_seed_runs"] = [
+ {"seed": seed, "core_swarm_state_bytes": baseline_bytes}
+ for seed in EXPECTED_SEEDS
+ ]
+ path = tmp_path / "mock_baseline.json"
+ with open(path, "w", encoding="utf-8") as f:
+ json.dump(payload, f)
+ return path
+
+
+def create_mock_candidate_json(
+ tmp_path: Path,
+ cand_id: str = "r0.5",
+ ratio: float = 0.5,
+ acc_deltas: Dict[str, float] = None,
+ nll_deltas: Dict[str, float] = None,
+ particles: int = 12,
+ epochs: int = 80,
+ subset_size: int = 10000,
+ seeds: list = None,
+ official_test_evals: int = 0,
+ test_loaded: bool = False,
+ is_finite: bool = True,
+) -> Path:
+ """Helper creating a minimal candidate heavy tasks JSON artifact."""
+ if seeds is None:
+ seeds = [101, 102, 103]
+ if acc_deltas is None:
+ acc_deltas = {"mnist_compact": 2.0, "mnist_wide": 3.0, "fashion_compact": 1.0, "fashion_wide": 1.0}
+ if nll_deltas is None:
+ nll_deltas = {"mnist_compact": -0.1, "mnist_wide": -0.1, "fashion_compact": -0.05, "fashion_wide": -0.05}
+
+ base_accs = {"mnist_compact": 50.0, "mnist_wide": 42.0, "fashion_compact": 48.0, "fashion_wide": 40.0}
+ base_nlls = {"mnist_compact": 1.50, "mnist_wide": 1.70, "fashion_compact": 1.60, "fashion_wide": 1.75}
+
+ wl_map = {}
+ for wl in EXPECTED_WORKLOADS:
+ c_acc = base_accs[wl] + acc_deltas.get(wl, 0.0)
+ c_nll = base_nlls[wl] + nll_deltas.get(wl, 0.0)
+
+ if not is_finite:
+ c_nll = float("nan")
+
+ total_dim = 9098 if "compact" in wl else 55338
+ latent_dim = compute_latent_dim(total_dim, ratio) if 0.0 < ratio <= 1.0 else max(1, int(total_dim * ratio))
+ state_bytes = compute_core_swarm_state_bytes(particles, latent_dim)
+ baseline_state_bytes = compute_baseline_core_swarm_state_bytes(
+ wl,
+ particles=particles,
+ total_dim=total_dim,
+ )
+
+ per_seed = []
+ for s in seeds:
+ per_seed.append(
+ {
+ "seed": s,
+ "val_selected_loss": c_nll,
+ "val_selected_acc": c_acc,
+ "val_metrics": {"brier": 0.6, "ece": 0.05},
+ "gbest_loss": c_nll,
+ "gbest_acc": c_acc,
+ "wall_time_sec": 1.0,
+ "total_queries": particles * epochs,
+ "total_sample_evaluations": particles * epochs * subset_size,
+ "official_test_evaluations": official_test_evals,
+ "core_swarm_state_bytes": state_bytes,
+ "is_finite": is_finite,
+ }
+ )
+
+ wl_map[wl] = {
+ "candidate_id": cand_id,
+ "ratio": ratio,
+ "workload_id": wl,
+ "total_dim": total_dim,
+ "latent_dim": latent_dim,
+ "state_ratio": state_bytes / baseline_state_bytes,
+ "particles": particles,
+ "epochs": epochs,
+ "subset_size": subset_size,
+ "seeds": seeds,
+ "core_swarm_state_bytes": state_bytes,
+ "stats": {
+ "val_nll": {"mean": c_nll},
+ "val_acc": {"mean": c_acc},
+ },
+ "per_seed_runs": per_seed,
+ }
+ payload = {
+ "protocol_version": AUTORESEARCH_PROTOCOL_VERSION,
+ "official_test_data_loaded": test_loaded,
+ "official_test_evaluations": official_test_evals * len(EXPECTED_WORKLOADS) * len(seeds),
+ "candidate_runs": {cand_id: wl_map},
+ }
+
+ path = tmp_path / f"mock_candidate_{cand_id}.json"
+ with open(path, "w", encoding="utf-8") as f:
+ json.dump(payload, f)
+ return path
+
+
+def test_evaluator_pass_fail_boundaries(tmp_path: Path):
+ """Verify evaluator hard gate boundaries for state ratio, acc regression, and NLL regression."""
+ b_path = create_mock_baseline_json(tmp_path)
+
+ # 1. Valid passing candidate
+ c_pass_path = create_mock_candidate_json(tmp_path, cand_id="r0.5", ratio=0.5)
+ res_pass = evaluate_heavy_autoresearch(b_path, c_pass_path)
+ assert res_pass["pass"] is True
+ assert res_pass["selected_candidate_id"] == "r0.5"
+ assert res_pass["candidate_evaluations"]["r0.5"]["pass"] is True
+ assert math.isfinite(res_pass["score"])
+
+ # 2. Gate 4 failure: state_ratio > 0.5
+ c_ratio_fail = create_mock_candidate_json(tmp_path, cand_id="r0.6", ratio=0.6)
+ res_ratio_fail = evaluate_heavy_autoresearch(b_path, c_ratio_fail)
+ assert res_ratio_fail["pass"] is False
+ assert "gate_state_ratio" in res_ratio_fail["candidate_evaluations"]["r0.6"]["failed_gates"]
+ assert math.isfinite(res_ratio_fail["score"])
+
+ # 3. Gate 5 failure: acc regression > 1.0 pp (e.g. -1.5 pp on fashion_compact)
+ acc_fail_deltas = {"mnist_compact": 2.0, "mnist_wide": 3.0, "fashion_compact": -1.5, "fashion_wide": 1.0}
+ c_acc_fail = create_mock_candidate_json(tmp_path, cand_id="r0.5_acc_fail", ratio=0.5, acc_deltas=acc_fail_deltas)
+ res_acc_fail = evaluate_heavy_autoresearch(b_path, c_acc_fail)
+ assert res_acc_fail["pass"] is False
+ assert "gate_acc_regression" in res_acc_fail["candidate_evaluations"]["r0.5_acc_fail"]["failed_gates"]
+ assert math.isfinite(res_acc_fail["score"])
+
+ # 4. Gate 6 failure: NLL regression > 5% (e.g. +10% NLL on fashion_wide)
+ # base fashion_wide NLL = 1.75 -> +10% is +0.175
+ nll_fail_deltas = {"mnist_compact": -0.1, "mnist_wide": -0.1, "fashion_compact": -0.05, "fashion_wide": 0.20}
+ c_nll_fail = create_mock_candidate_json(tmp_path, cand_id="r0.5_nll_fail", ratio=0.5, nll_deltas=nll_fail_deltas)
+ res_nll_fail = evaluate_heavy_autoresearch(b_path, c_nll_fail)
+ assert res_nll_fail["pass"] is False
+ assert "gate_nll_regression" in res_nll_fail["candidate_evaluations"]["r0.5_nll_fail"]["failed_gates"]
+ assert math.isfinite(res_nll_fail["score"])
+
+def test_evaluator_or_worst_workload_gate(tmp_path: Path):
+ """Verify Gate 7 (mnist_wide worst-workload improvement) OR condition."""
+ b_path = create_mock_baseline_json(tmp_path)
+
+ # Case A: acc_gain >= 2.0 pp (e.g. +2.5 pp), but NLL reduction < 5.0% (e.g. 0.0%) -> PASS
+ c_a = create_mock_candidate_json(
+ tmp_path,
+ cand_id="case_a",
+ ratio=0.5,
+ acc_deltas={"mnist_compact": 1.0, "mnist_wide": 2.5, "fashion_compact": 0.0, "fashion_wide": 0.0},
+ nll_deltas={"mnist_compact": 0.0, "mnist_wide": 0.0, "fashion_compact": 0.0, "fashion_wide": 0.0},
+ )
+ res_a = evaluate_heavy_autoresearch(b_path, c_a)
+ assert res_a["candidate_evaluations"]["case_a"]["gate_details"]["gate_baseline_worst_improvement"] is True
+ assert res_a["pass"] is True
+ assert math.isfinite(res_a["score"])
+
+ # Case B: acc_gain < 2.0 pp (e.g. +0.5 pp), but NLL reduction >= 5.0% (e.g. -0.10 NLL on 1.70 baseline = ~5.88%) -> PASS
+ c_b = create_mock_candidate_json(
+ tmp_path,
+ cand_id="case_b",
+ ratio=0.5,
+ acc_deltas={"mnist_compact": 0.0, "mnist_wide": 0.5, "fashion_compact": 0.0, "fashion_wide": 0.0},
+ nll_deltas={"mnist_compact": 0.0, "mnist_wide": -0.10, "fashion_compact": 0.0, "fashion_wide": 0.0},
+ )
+ res_b = evaluate_heavy_autoresearch(b_path, c_b)
+ assert res_b["candidate_evaluations"]["case_b"]["gate_details"]["gate_baseline_worst_improvement"] is True
+ assert res_b["pass"] is True
+ assert math.isfinite(res_b["score"])
+
+ # Case C: acc_gain = 1.0 pp (< 2.0), NLL reduction = 2.0% (< 5.0%) -> FAIL Gate 7
+ # -0.034 NLL on 1.70 = ~2.0%
+ c_c = create_mock_candidate_json(
+ tmp_path,
+ cand_id="case_c",
+ ratio=0.5,
+ acc_deltas={"mnist_compact": 0.0, "mnist_wide": 1.0, "fashion_compact": 0.0, "fashion_wide": 0.0},
+ nll_deltas={"mnist_compact": 0.0, "mnist_wide": -0.034, "fashion_compact": 0.0, "fashion_wide": 0.0},
+ )
+ res_c = evaluate_heavy_autoresearch(b_path, c_c)
+ assert res_c["candidate_evaluations"]["case_c"]["gate_details"]["gate_baseline_worst_improvement"] is False
+ assert res_c["pass"] is False
+ assert math.isfinite(res_c["score"])
+
+def test_config_mismatch(tmp_path: Path):
+ """Verify mismatched particle, epoch, or seed configurations fail gate_config_matched."""
+ b_path = create_mock_baseline_json(tmp_path)
+
+ # Particle mismatch (particles=10 instead of 12)
+ c_part_path = create_mock_candidate_json(tmp_path, cand_id="p_mismatch", particles=10)
+ res_p = evaluate_heavy_autoresearch(b_path, c_part_path)
+ assert res_p["pass"] is False
+ assert "gate_config_matched" in res_p["candidate_evaluations"]["p_mismatch"]["failed_gates"]
+ assert math.isfinite(res_p["score"])
+
+ # Epoch mismatch (epochs=40 instead of 80)
+ c_epoch_path = create_mock_candidate_json(tmp_path, cand_id="e_mismatch", epochs=40)
+ res_e = evaluate_heavy_autoresearch(b_path, c_epoch_path)
+ assert res_e["pass"] is False
+ assert "gate_config_matched" in res_e["candidate_evaluations"]["e_mismatch"]["failed_gates"]
+ assert math.isfinite(res_e["score"])
+
+def test_nonfinite_rejection(tmp_path: Path):
+ """Verify non-finite metrics fail gate_finite."""
+ b_path = create_mock_baseline_json(tmp_path)
+ c_nan_path = create_mock_candidate_json(tmp_path, cand_id="nan_cand", is_finite=False)
+ res = evaluate_heavy_autoresearch(b_path, c_nan_path)
+ assert res["pass"] is False
+ assert "gate_finite" in res["candidate_evaluations"]["nan_cand"]["failed_gates"]
+ assert math.isfinite(res["score"])
+
+def test_zero_test_enforcement(tmp_path: Path):
+ """Verify official test data load or test evaluations > 0 fail gate_test_sealed."""
+ b_path = create_mock_baseline_json(tmp_path)
+
+ # Test evaluations > 0
+ c_eval_path = create_mock_candidate_json(tmp_path, cand_id="test_eval", official_test_evals=10)
+ res_eval = evaluate_heavy_autoresearch(b_path, c_eval_path)
+ assert res_eval["pass"] is False
+ assert "gate_test_sealed" in res_eval["candidate_evaluations"]["test_eval"]["failed_gates"]
+ assert math.isfinite(res_eval["score"])
+
+ # Test data loaded = True
+ c_load_path = create_mock_candidate_json(tmp_path, cand_id="test_load", test_loaded=True)
+ res_load = evaluate_heavy_autoresearch(b_path, c_load_path)
+ assert res_load["pass"] is False
+ assert "gate_test_sealed" in res_load["candidate_evaluations"]["test_load"]["failed_gates"]
+ assert math.isfinite(res_load["score"])
+
+def test_selection_preference_for_passing_candidates(tmp_path: Path):
+ """Verify passing candidate is preferred over a higher unpenalized score candidate that fails a gate."""
+ b_path = create_mock_baseline_json(tmp_path)
+
+ # Cand A: passes all gates, modest score
+ c_a_path = create_mock_candidate_json(
+ tmp_path,
+ cand_id="r0.5_pass",
+ ratio=0.5,
+ acc_deltas={"mnist_compact": 1.0, "mnist_wide": 2.5, "fashion_compact": 0.0, "fashion_wide": 0.0},
+ )
+ with open(c_a_path, "r", encoding="utf-8") as f:
+ data_a = json.load(f)
+
+ # Cand B: state_ratio = 0.6 (> 0.5), huge acc gain -> higher unpenalized score
+ c_b_path = create_mock_candidate_json(
+ tmp_path,
+ cand_id="r0.6_fail",
+ ratio=0.6,
+ acc_deltas={"mnist_compact": 20.0, "mnist_wide": 20.0, "fashion_compact": 20.0, "fashion_wide": 20.0},
+ )
+ with open(c_b_path, "r", encoding="utf-8") as f:
+ data_b = json.load(f)
+
+ # Combine into single candidate payload
+ combined_payload = {
+ "protocol_version": AUTORESEARCH_PROTOCOL_VERSION,
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "candidate_runs": {
+ "r0.5_pass": data_a["candidate_runs"]["r0.5_pass"],
+ "r0.6_fail": data_b["candidate_runs"]["r0.6_fail"],
+ },
+ }
+
+ combined_path = tmp_path / "combined_candidates.json"
+ with open(combined_path, "w", encoding="utf-8") as f:
+ json.dump(combined_payload, f)
+
+ res = evaluate_heavy_autoresearch(b_path, combined_path)
+
+ assert res["pass"] is True
+ assert res["selected_candidate_id"] == "r0.5_pass", "Must select passing candidate over failing candidate"
+ assert math.isfinite(res["score"])
+
+def test_artifact_json_safety(tmp_path: Path):
+ """Verify artifact payload structures dump cleanly to JSON without PyTorch tensor objects."""
+ b_path = create_mock_baseline_json(tmp_path)
+ c_path = create_mock_candidate_json(tmp_path, cand_id="safety_test")
+ res = evaluate_heavy_autoresearch(b_path, c_path)
+
+ json_str = json.dumps(res)
+ assert "tensor" not in json_str.lower()
+ assert isinstance(json.loads(json_str), dict)
+ assert math.isfinite(res["score"])
+
+def test_tiny_synthetic_experiment_runner(monkeypatch, tmp_path: Path):
+ """Smoke test running run_heavy_pso_autoresearch on CPU with synthetic dataset monkeypatch."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ out_file = tmp_path / "synthetic_candidates.json"
+
+ # Run tiny synthetic experiment on CPU: 2 particles, 2 epochs, subset_size=10, 1 ratio, 1 seed
+ payload = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ device_str="cpu",
+ cache_dir=tmp_path,
+ output_path=out_file,
+ )
+
+ assert out_file.is_file(), "Candidate artifact file must be atomically created"
+ assert payload["protocol_version"] == AUTORESEARCH_PROTOCOL_VERSION
+ assert payload["official_test_data_loaded"] is False
+ assert payload["official_test_evaluations"] == 0
+ assert "r0.5" in payload["candidate_runs"]
+ assert "mnist_compact" in payload["candidate_runs"]["r0.5"]
+
+ wl_res = payload["candidate_runs"]["r0.5"]["mnist_compact"]
+ assert wl_res["particles"] == 2
+ assert wl_res["epochs"] == 2
+ assert wl_res["per_seed_runs"][0]["official_test_evaluations"] == 0
+
+
+def test_latent_dim_half_up_and_invalid_ratios():
+ """Verify compute_latent_dim half-up rounding and 0 < ratio <= 1 bounds enforcement."""
+ assert compute_latent_dim(9098, 0.25) == 2275
+ assert compute_latent_dim(9098, 0.5) == 4549
+ assert compute_latent_dim(55338, 0.25) == 13835
+
+ with pytest.raises(ValueError):
+ compute_latent_dim(9098, 0.0)
+ with pytest.raises(ValueError):
+ compute_latent_dim(9098, -0.5)
+ with pytest.raises(ValueError):
+ compute_latent_dim(9098, 1.25)
+
+
+def test_evaluator_required_test_flags(tmp_path: Path):
+ """Verify missing or non-sealed test flags fail gate_test_sealed and produce finite score."""
+ b_path = create_mock_baseline_json(tmp_path)
+ c_path = create_mock_candidate_json(tmp_path, cand_id="flag_test")
+
+ with open(c_path, "r", encoding="utf-8") as f:
+ data = json.load(f)
+
+ # Case 1: Missing top-level test flags
+ data_missing = dict(data)
+ data_missing.pop("official_test_data_loaded", None)
+ p1 = tmp_path / "cand_missing_flags.json"
+ with open(p1, "w", encoding="utf-8") as f:
+ json.dump(data_missing, f)
+ res1 = evaluate_heavy_autoresearch(b_path, p1)
+ assert res1["pass"] is False
+ assert "gate_test_sealed" in res1["candidate_evaluations"]["flag_test"]["failed_gates"]
+ assert math.isfinite(res1["score"])
+
+ # Case 2: Per-seed test evaluations > 0
+ data_seed_evals = json.loads(json.dumps(data))
+ data_seed_evals["candidate_runs"]["flag_test"]["mnist_compact"]["per_seed_runs"][0]["official_test_evaluations"] = 5
+ p2 = tmp_path / "cand_seed_evals.json"
+ with open(p2, "w", encoding="utf-8") as f:
+ json.dump(data_seed_evals, f)
+ res2 = evaluate_heavy_autoresearch(b_path, p2)
+ assert res2["pass"] is False
+ assert "gate_test_sealed" in res2["candidate_evaluations"]["flag_test"]["failed_gates"]
+ assert math.isfinite(res2["score"])
+
+
+def test_evaluator_forged_state_ratio_and_core_bytes(tmp_path: Path):
+ """Verify forged state_ratio or core_swarm_state_bytes are rejected and produce finite score."""
+ b_path = create_mock_baseline_json(tmp_path)
+
+ # Forged state ratio: claims ratio 0.1 but actual parameter ratio is 0.6
+ c_path = create_mock_candidate_json(tmp_path, cand_id="forged_ratio", ratio=0.6)
+ with open(c_path, "r", encoding="utf-8") as f:
+ data = json.load(f)
+ for wl in EXPECTED_WORKLOADS:
+ data["candidate_runs"]["forged_ratio"][wl]["state_ratio"] = 0.1
+ p_forged_sr = tmp_path / "forged_sr.json"
+ with open(p_forged_sr, "w", encoding="utf-8") as f:
+ json.dump(data, f)
+ res_sr = evaluate_heavy_autoresearch(b_path, p_forged_sr)
+ assert res_sr["pass"] is False
+ assert "gate_state_ratio" in res_sr["candidate_evaluations"]["forged_ratio"]["failed_gates"]
+ assert "gate_config_matched" in res_sr["candidate_evaluations"]["forged_ratio"]["failed_gates"]
+ assert math.isfinite(res_sr["score"])
+
+ # Forged core swarm state bytes: claims wrong byte footprint
+ c_path2 = create_mock_candidate_json(tmp_path, cand_id="forged_bytes", ratio=0.5)
+ with open(c_path2, "r", encoding="utf-8") as f:
+ data2 = json.load(f)
+ for wl in EXPECTED_WORKLOADS:
+ data2["candidate_runs"]["forged_bytes"][wl]["core_swarm_state_bytes"] = 12345
+ p_forged_b = tmp_path / "forged_b.json"
+ with open(p_forged_b, "w", encoding="utf-8") as f:
+ json.dump(data2, f)
+ res_b = evaluate_heavy_autoresearch(b_path, p_forged_b)
+ assert res_b["pass"] is False
+ assert "gate_config_matched" in res_b["candidate_evaluations"]["forged_bytes"]["failed_gates"]
+ assert math.isfinite(res_b["score"])
+
+
+def test_evaluator_missing_and_duplicate_seeds(tmp_path: Path):
+ """Verify non-3 or duplicate/incorrect seed records fail gate_config_matched and emit finite score."""
+ b_path = create_mock_baseline_json(tmp_path)
+
+ # Duplicate seed: [101, 102, 102]
+ c_dup = create_mock_candidate_json(tmp_path, cand_id="dup_seed", ratio=0.5, seeds=[101, 102, 102])
+ res_dup = evaluate_heavy_autoresearch(b_path, c_dup)
+ assert res_dup["pass"] is False
+ assert "gate_config_matched" in res_dup["candidate_evaluations"]["dup_seed"]["failed_gates"]
+ assert math.isfinite(res_dup["score"])
+
+ # Missing seed (2 seeds instead of 3)
+ c_miss = create_mock_candidate_json(tmp_path, cand_id="miss_seed", ratio=0.5, seeds=[101, 102])
+ res_miss = evaluate_heavy_autoresearch(b_path, c_miss)
+ assert res_miss["pass"] is False
+ assert "gate_config_matched" in res_miss["candidate_evaluations"]["miss_seed"]["failed_gates"]
+ assert math.isfinite(res_miss["score"])
+
+
+def test_evaluator_infinite_baseline_and_candidate_metrics(tmp_path: Path):
+ """Verify infinite/nan baseline or candidate metrics raise ValueError or fail gate_finite cleanly with finite score."""
+ # Invalid baseline with NaN
+ p_bad_b = tmp_path / "bad_baseline.json"
+ with open(p_bad_b, "w", encoding="utf-8") as f:
+ json.dump({
+ "confirmation_results": {
+ "mnist_compact": {"G8": {"stats": {"val_nll": {"mean": float("nan")}, "val_acc": {"mean": 50.0}}}},
+ "mnist_wide": {"G5": {"stats": {"val_nll": {"mean": 1.70}, "val_acc": {"mean": 42.0}}}},
+ "fashion_compact": {"G8": {"stats": {"val_nll": {"mean": 1.60}, "val_acc": {"mean": 48.0}}}},
+ "fashion_wide": {"G5": {"stats": {"val_nll": {"mean": 1.75}, "val_acc": {"mean": 40.0}}}},
+ }
+ }, f)
+ c_valid = create_mock_candidate_json(tmp_path, cand_id="valid_c")
+ with pytest.raises(ValueError):
+ evaluate_heavy_autoresearch(p_bad_b, c_valid)
+
+ # Candidate with inf metric
+ b_path = create_mock_baseline_json(tmp_path)
+ c_inf = create_mock_candidate_json(tmp_path, cand_id="inf_cand", ratio=0.5)
+ with open(c_inf, "r", encoding="utf-8") as f:
+ data_inf = json.load(f)
+ data_inf["candidate_runs"]["inf_cand"]["mnist_compact"]["per_seed_runs"][0]["val_selected_loss"] = float("inf")
+ p_inf = tmp_path / "cand_inf.json"
+ with open(p_inf, "w", encoding="utf-8") as f:
+ json.dump(data_inf, f)
+ res_inf = evaluate_heavy_autoresearch(b_path, p_inf)
+ assert res_inf["pass"] is False
+ assert "gate_finite" in res_inf["candidate_evaluations"]["inf_cand"]["failed_gates"]
+ assert math.isfinite(res_inf["score"])
+
+
+def test_geometry_policy_mappings():
+ """Verify GEOMETRY_POLICIES contains 'recovered' and 'baseline_aligned' with exact workload mappings."""
+ assert "recovered" in GEOMETRY_POLICIES
+ assert "baseline_aligned" in GEOMETRY_POLICIES
+
+ assert GEOMETRY_POLICIES["recovered"]["mnist_compact"] == "G6"
+ assert GEOMETRY_POLICIES["recovered"]["mnist_wide"] == "G5"
+ assert GEOMETRY_POLICIES["recovered"]["fashion_compact"] == "G6"
+ assert GEOMETRY_POLICIES["recovered"]["fashion_wide"] == "G5"
+
+ assert GEOMETRY_POLICIES["baseline_aligned"]["mnist_compact"] == "G8"
+ assert GEOMETRY_POLICIES["baseline_aligned"]["mnist_wide"] == "G5"
+ assert GEOMETRY_POLICIES["baseline_aligned"]["fashion_compact"] == "G8"
+ assert GEOMETRY_POLICIES["baseline_aligned"]["fashion_wide"] == "G5"
+
+
+def test_invalid_geometry_policy_rejection(tmp_path: Path):
+ """Verify run_heavy_pso_autoresearch raises ValueError for unrecognised geometry policy."""
+ with pytest.raises(ValueError, match="Invalid geometry_policy"):
+ run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ geometry_policy="invalid_policy_name",
+ )
+
+
+def test_format_ratio_id_behavior():
+ """Verify format_ratio_id returns 'r' for recovered and 'aligned_r' for baseline_aligned."""
+ assert format_ratio_id(0.5, "recovered") == "r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned") == "aligned_r0.5"
+ assert format_ratio_id(1.0, "recovered") == "r1"
+ assert format_ratio_id(1.0, "baseline_aligned") == "aligned_r1"
+ assert format_ratio_id(0.03125, "baseline_aligned") == "aligned_r0.03125"
+ assert format_ratio_id(0.5, "recovered", "tensor_local") == "local_r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", "tensor_local") == "local_aligned_r0.5"
+ assert format_ratio_id(0.125, "baseline_aligned", "tensor_local") == "local_aligned_r0.125"
+
+
+def test_projection_seeds_identical_across_policies():
+ """Verify projection seeds depend only on workload, ratio, and seed, NOT geometry policy."""
+ for wl in ["mnist_compact", "mnist_wide", "fashion_compact", "fashion_wide"]:
+ for r in [1.0, 0.5, 0.25]:
+ for s in [101, 102, 103]:
+ seed1 = derive_projection_seed(wl, r, s)
+ seed2 = derive_projection_seed(wl, r, s)
+ assert seed1 == seed2
+
+
+def test_baseline_aligned_compact_g8_wide_g5_construction():
+ """Verify baseline_aligned policy constructs equalized geometries from G8 for compact and G5 for wide."""
+ geom_table = get_v6_geometry_table()
+
+ # Compact workload under baseline_aligned uses G8 base
+ base_compact_g8 = geom_table["G8"]
+ eq_compact = construct_equalized_geometry(
+ base_geom=base_compact_g8,
+ total_dim=9098,
+ latent_dim=4549,
+ projection_seed=12345,
+ ratio_str="aligned_r0.5",
+ )
+ assert eq_compact.config_id == "G8_eq_aligned_r0.5"
+ assert math.isclose(eq_compact.position_radius, base_compact_g8.position_radius * math.sqrt(9098 / 4549))
+
+ # Wide workload under baseline_aligned uses G5 base
+ base_wide_g5 = geom_table["G5"]
+ eq_wide = construct_equalized_geometry(
+ base_geom=base_wide_g5,
+ total_dim=55338,
+ latent_dim=27669,
+ projection_seed=12345,
+ ratio_str="aligned_r0.5",
+ )
+ assert eq_wide.config_id == "G5_eq_aligned_r0.5"
+ assert math.isclose(eq_wide.position_radius, base_wide_g5.position_radius * math.sqrt(55338 / 27669))
+
+ # Diagnostic ratio 1.0 (latent_dim == total_dim) produces unscaled geometry
+ eq_r1 = construct_equalized_geometry(
+ base_geom=base_compact_g8,
+ total_dim=9098,
+ latent_dim=9098,
+ projection_seed=12345,
+ ratio_str="aligned_r1",
+ )
+ assert eq_r1.latent_dim == 9098
+ assert math.isclose(eq_r1.position_radius, base_compact_g8.position_radius)
+ assert math.isclose(eq_r1.reflective_bound, base_compact_g8.reflective_bound)
+
+
+def test_synthetic_experiment_runner_baseline_aligned(monkeypatch, tmp_path: Path):
+ """Smoke test running run_heavy_pso_autoresearch with baseline_aligned policy."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ payload = run_heavy_pso_autoresearch(
+ ratios=[1.0, 0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ geometry_policy="baseline_aligned",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert payload["experiment_config"]["geometry_policy"] == "baseline_aligned"
+ assert "aligned_r1" in payload["candidate_runs"]
+ assert "aligned_r0.5" in payload["candidate_runs"]
+
+ # Verify per-workload geometry IDs and policy provenance
+ assert payload["workloads"]["mnist_compact"]["base_geometry_id"] == "G8"
+ assert payload["workloads"]["mnist_wide"]["base_geometry_id"] == "G5"
+ assert payload["workloads"]["mnist_compact"]["geometry_policy"] == "baseline_aligned"
+ assert payload["workloads"]["mnist_wide"]["geometry_policy"] == "baseline_aligned"
+ assert payload["candidate_runs"]["aligned_r1"]["mnist_compact"]["base_geometry_id"] == "G8"
+ assert payload["candidate_runs"]["aligned_r1"]["mnist_wide"]["base_geometry_id"] == "G5"
+ assert payload["candidate_runs"]["aligned_r1"]["mnist_compact"]["geometry_policy"] == "baseline_aligned"
+
+
+def test_projection_salt_empty_backward_compatibility():
+ """Verify empty projection_salt reproduces exact legacy projection seeds."""
+ seed_implicit = derive_projection_seed("mnist_compact", 0.5, 101)
+ seed_explicit_empty = derive_projection_seed("mnist_compact", 0.5, 101, "")
+ assert seed_implicit == seed_explicit_empty, "Implicit and explicit empty salt must produce identical projection seeds"
+
+ # Verify against exact hash calculation
+
+ expected_key = f"mnist_compact:0.50000:101".encode("utf-8")
+ expected_seed = int(hashlib.sha256(expected_key).hexdigest()[:8], 16) % (2**31 - 1)
+ assert seed_implicit == expected_seed, "Empty salt must match exact legacy sha256 hash key"
+
+
+def test_projection_salt_nonempty_deterministic_variation():
+ """Verify nonempty projection_salt changes seed deterministically and varies by salt, workload, ratio, and seed."""
+ base_seed = derive_projection_seed("mnist_compact", 0.5, 101, "")
+ salted_seed1 = derive_projection_seed("mnist_compact", 0.5, 101, "replica-1")
+ salted_seed1_again = derive_projection_seed("mnist_compact", 0.5, 101, "replica-1")
+
+ # Nonempty salt must differ from empty salt
+ assert salted_seed1 != base_seed, "Nonempty salt must produce a different projection seed than empty salt"
+
+ # Determinism / stability across calls
+ assert salted_seed1 == salted_seed1_again, "Projection seed with salt must be deterministic across calls"
+
+ # Salt variation
+ salted_seed2 = derive_projection_seed("mnist_compact", 0.5, 101, "replica-2")
+ assert salted_seed1 != salted_seed2, "Different salt strings must produce different projection seeds"
+
+ # Workload, ratio, and swarm seed variation under nonempty salt
+ diff_wl = derive_projection_seed("mnist_wide", 0.5, 101, "replica-1")
+ diff_ratio = derive_projection_seed("mnist_compact", 0.25, 101, "replica-1")
+ diff_swarm_seed = derive_projection_seed("mnist_compact", 0.5, 102, "replica-1")
+
+ assert salted_seed1 != diff_wl, "Salted projection seed must vary by workload"
+ assert salted_seed1 != diff_ratio, "Salted projection seed must vary by ratio"
+ assert salted_seed1 != diff_swarm_seed, "Salted projection seed must vary by swarm seed"
+
+
+def test_runner_provenance_and_projection_salt_persistence(monkeypatch, tmp_path: Path):
+ """Verify projection_salt is persisted in experiment_config and per_seed_runs."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ # Salted run
+ payload_salted = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ geometry_policy="baseline_aligned",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ projection_salt="replica-1",
+ )
+
+ assert payload_salted["experiment_config"]["projection_salt"] == "replica-1"
+ seed_rec_salted = payload_salted["candidate_runs"]["aligned_r0.5"]["mnist_compact"]["per_seed_runs"][0]
+ assert seed_rec_salted["projection_salt"] == "replica-1"
+ expected_salted_proj_seed = derive_projection_seed("mnist_compact", 0.5, 101, "replica-1")
+ assert seed_rec_salted["projection_seed"] == expected_salted_proj_seed
+
+ # Unsalted run (default)
+ payload_unsalted = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ geometry_policy="baseline_aligned",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert payload_unsalted["experiment_config"]["projection_salt"] == ""
+ seed_rec_unsalted = payload_unsalted["candidate_runs"]["aligned_r0.5"]["mnist_compact"]["per_seed_runs"][0]
+ assert seed_rec_unsalted["projection_salt"] == ""
+ expected_unsalted_proj_seed = derive_projection_seed("mnist_compact", 0.5, 101, "")
+ assert seed_rec_unsalted["projection_seed"] == expected_unsalted_proj_seed
+
+
+def test_projection_salt_no_change_to_query_and_sample_accounting(monkeypatch, tmp_path: Path):
+ """Verify projection_salt preserves query, sample, and evaluation accounting, candidate IDs, and schema."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ payload_base = run_heavy_pso_autoresearch(
+ ratios=[0.5, 0.125],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101, 102],
+ geometry_policy="baseline_aligned",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ projection_salt="",
+ )
+
+ payload_salted = run_heavy_pso_autoresearch(
+ ratios=[0.5, 0.125],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101, 102],
+ geometry_policy="baseline_aligned",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ projection_salt="replica-1",
+ )
+
+ # Candidate IDs must be identical
+ assert list(payload_base["candidate_runs"].keys()) == list(payload_salted["candidate_runs"].keys())
+ assert "aligned_r0.5" in payload_salted["candidate_runs"]
+ assert "aligned_r0.125" in payload_salted["candidate_runs"]
+
+ # Accounting fields in experiment_config must be identical
+ base_cfg = payload_base["experiment_config"]
+ salted_cfg = payload_salted["experiment_config"]
+ assert base_cfg["total_runs"] == salted_cfg["total_runs"]
+ assert base_cfg["total_queries"] == salted_cfg["total_queries"]
+ assert base_cfg["total_sample_evaluations"] == salted_cfg["total_sample_evaluations"]
+ assert base_cfg["particles"] == salted_cfg["particles"]
+ assert base_cfg["epochs"] == salted_cfg["epochs"]
+ assert base_cfg["subset_size"] == salted_cfg["subset_size"]
+ assert base_cfg["seeds"] == salted_cfg["seeds"]
+
+ # Per seed runs accounting fields must be identical
+ for cand_id in payload_base["candidate_runs"]:
+ for wl_id in payload_base["candidate_runs"][cand_id]:
+ base_runs = payload_base["candidate_runs"][cand_id][wl_id]["per_seed_runs"]
+ salted_runs = payload_salted["candidate_runs"][cand_id][wl_id]["per_seed_runs"]
+ for r_base, r_salted in zip(base_runs, salted_runs):
+ assert r_base["total_queries"] == r_salted["total_queries"]
+ assert r_base["total_sample_evaluations"] == r_salted["total_sample_evaluations"]
+ assert r_base["official_test_evaluations"] == r_salted["official_test_evaluations"]
+ assert r_base["core_swarm_state_bytes"] == r_salted["core_swarm_state_bytes"]
+
+
+def test_cli_projection_salt_argument_parsing():
+ """Verify CLI parser handles default and explicit --projection-salt flag."""
+ parser = build_parser()
+ args_default = parser.parse_args([])
+ assert args_default.projection_salt == ""
+
+ args_salted = parser.parse_args(["--projection-salt", "replica-1"])
+ assert args_salted.projection_salt == "replica-1"
+
+
+def test_tensor_local_allocation_invariants():
+ """Verify allocate_tensor_latent_dims handles uneven/tiny tensors with exact sum and cap invariants."""
+ import pytest
+ # CompactCNN numels: [72, 8, 1152, 16, 7840, 10], aggregate_latent_dim = 284
+ numels = [72, 8, 1152, 16, 7840, 10]
+ total_dim = sum(numels)
+ target_d = 284
+ allocs = allocate_tensor_latent_dims(numels, target_d)
+
+ assert sum(allocs) == target_d, "Exact sum must match target aggregate latent dim"
+ assert len(allocs) == len(numels)
+ for a, n in zip(allocs, numels):
+ assert 1 <= a <= n, "Each tensor must get at least 1 coordinate and not exceed numel"
+
+ # Extreme tiny tensors case: numels = [1, 1, 100], aggregate_latent_dim = 10
+ tiny_numels = [1, 1, 100]
+ tiny_allocs = allocate_tensor_latent_dims(tiny_numels, 10)
+ assert tiny_allocs == [1, 1, 8]
+ assert sum(tiny_allocs) == 10
+
+ # Full dimensional allocation
+ full_allocs = allocate_tensor_latent_dims(numels, total_dim)
+ assert full_allocs == numels
+
+ # Invalid allocation rejections
+ with pytest.raises(ValueError):
+ allocate_tensor_latent_dims(numels, 0)
+ with pytest.raises(ValueError):
+ allocate_tensor_latent_dims(numels, total_dim + 1)
+ with pytest.raises(ValueError):
+ allocate_tensor_latent_dims(numels, 2) # target_d < len(numels)
+
+
+def test_tensor_local_transform_coordinate_containment_and_decoding():
+ """Verify TensorLocalLatentTransform restricts each tensor to its contiguous slice and decodes correctly."""
+ class DummyModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.fc1 = nn.Linear(10, 5) # 50 weight + 5 bias = 55
+ self.conv = nn.Conv2d(1, 4, 3) # 36 weight + 4 bias = 40
+ self.fc2 = nn.Linear(4, 2) # 8 weight + 2 bias = 10
+ # Total dim = 105, 6 parameter tensors
+
+ model = DummyModel()
+ geom_table = get_v6_geometry_table()
+ base_geom = geom_table["G6"]
+ total_dim = sum(p.numel() for p in model.parameters())
+ latent_dim = 30
+ proj_seed = 12345
+
+ geom_cfg = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=latent_dim,
+ projection_seed=proj_seed,
+ ratio_str="r0.3",
+ )
+
+ device = torch.device("cpu")
+ transform = TensorLocalLatentTransform(model, geom_cfg, device)
+
+ assert not transform.is_full
+ assert len(transform.tensor_latent_dims) == len(transform.param_numels)
+ assert sum(transform.tensor_latent_dims) == latent_dim
+
+ # Verify each parameter's k_index lies strictly within its tensor's allocated slice
+ j_offset = 0
+ l_offset = 0
+ for numel, d_m in zip(transform.param_numels, transform.tensor_latent_dims):
+ k_slice = transform.k_indices[j_offset : j_offset + numel]
+ assert (k_slice >= l_offset).all()
+ assert (k_slice < l_offset + d_m).all()
+ j_offset += numel
+ l_offset += d_m
+
+ # Verify finite decoding shape
+ Z = torch.randn(5, latent_dim, device=device)
+ theta = transform.decode(Z)
+ assert theta.shape == (5, total_dim)
+ assert torch.isfinite(theta).all()
+
+
+def test_tensor_local_transform_determinism_and_seed_variation():
+ """Verify TensorLocalLatentTransform is deterministic for identical seeds and varies across seeds."""
+ model = nn.Sequential(nn.Linear(20, 10), nn.Linear(10, 2))
+ geom_table = get_v6_geometry_table()
+ base_geom = geom_table["G6"]
+ total_dim = sum(p.numel() for p in model.parameters())
+ latent_dim = 40
+ device = torch.device("cpu")
+
+ geom_cfg1 = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=latent_dim,
+ projection_seed=999,
+ ratio_str="r0.2",
+ )
+ geom_cfg1_dup = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=latent_dim,
+ projection_seed=999,
+ ratio_str="r0.2",
+ )
+ geom_cfg2 = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=latent_dim,
+ projection_seed=1000,
+ ratio_str="r0.2",
+ )
+
+ t1 = TensorLocalLatentTransform(model, geom_cfg1, device)
+ t1_dup = TensorLocalLatentTransform(model, geom_cfg1_dup, device)
+ t2 = TensorLocalLatentTransform(model, geom_cfg2, device)
+
+ assert torch.equal(t1.k_indices, t1_dup.k_indices)
+ assert torch.equal(t1.weights, t1_dup.weights)
+
+ # Different projection seed must yield different projection indices or weights
+ assert not (torch.equal(t1.k_indices, t2.k_indices) and torch.equal(t1.weights, t2.weights))
+
+
+def test_tensor_local_full_dimensional_behavior():
+ """Verify TensorLocalLatentTransform preserves full-dimensional behavior when latent_dim == total_dim."""
+ model = nn.Sequential(nn.Linear(10, 5))
+ geom_table = get_v6_geometry_table()
+ base_geom = geom_table["G6"]
+ total_dim = sum(p.numel() for p in model.parameters())
+
+ geom_cfg = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=total_dim,
+ projection_seed=42,
+ ratio_str="r1.0",
+ )
+
+ device = torch.device("cpu")
+ transform = TensorLocalLatentTransform(model, geom_cfg, device)
+
+ assert transform.is_full
+ assert transform.tensor_latent_dims == transform.param_numels
+
+ Z = torch.randn(3, total_dim, device=device)
+ theta = transform.decode(Z)
+ assert theta.shape == (3, total_dim)
+ assert torch.isfinite(theta).all()
+
+
+def test_tensor_local_runner_provenance_and_persistence(monkeypatch, tmp_path: Path):
+ """Verify projection_scope='tensor_local' persists in experiment_config, workloads, candidate_runs, and per_seed_runs."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ payload = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ geometry_policy="baseline_aligned",
+ projection_scope="tensor_local",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert payload["experiment_config"]["projection_scope"] == "tensor_local"
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "tensor_local"
+ assert "local_aligned_r0.5" in payload["candidate_runs"]
+
+ cand_rec = payload["candidate_runs"]["local_aligned_r0.5"]["mnist_compact"]
+ assert cand_rec["projection_scope"] == "tensor_local"
+ assert cand_rec["candidate_id"] == "local_aligned_r0.5"
+
+ seed_rec = cand_rec["per_seed_runs"][0]
+ assert seed_rec["projection_scope"] == "tensor_local"
+
+
+def test_default_global_backward_compatibility(monkeypatch, tmp_path: Path):
+ """Verify default projection_scope is 'global' and produces byte/seed/candidate-ID compatible output."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ payload_default = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ geometry_policy="baseline_aligned",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ payload_global = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert payload_default["experiment_config"]["projection_scope"] == "global"
+ assert list(payload_default["candidate_runs"].keys()) == ["aligned_r0.5"]
+ assert list(payload_default["candidate_runs"].keys()) == list(payload_global["candidate_runs"].keys())
+
+ rec_def = payload_default["candidate_runs"]["aligned_r0.5"]["mnist_compact"]["per_seed_runs"][0]
+ rec_glo = payload_global["candidate_runs"]["aligned_r0.5"]["mnist_compact"]["per_seed_runs"][0]
+ assert rec_def["projection_seed"] == rec_glo["projection_seed"]
+ assert rec_def["core_swarm_state_bytes"] == rec_glo["core_swarm_state_bytes"]
+
+
+def test_tensor_local_no_change_to_state_query_sample_accounting(monkeypatch, tmp_path: Path):
+ """Verify projection_scope='tensor_local' preserves total queries, samples, state bytes, and baseline bytes."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ payload_global = run_heavy_pso_autoresearch(
+ ratios=[0.5, 0.125],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101, 102],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ payload_local = run_heavy_pso_autoresearch(
+ ratios=[0.5, 0.125],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101, 102],
+ geometry_policy="baseline_aligned",
+ projection_scope="tensor_local",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ cfg_glo = payload_global["experiment_config"]
+ cfg_loc = payload_local["experiment_config"]
+ assert cfg_glo["total_runs"] == cfg_loc["total_runs"]
+ assert cfg_glo["total_queries"] == cfg_loc["total_queries"]
+ assert cfg_glo["total_sample_evaluations"] == cfg_loc["total_sample_evaluations"]
+
+ for c_glo, c_loc in zip(payload_global["candidate_runs"].values(), payload_local["candidate_runs"].values()):
+ for wl_id in c_glo:
+ assert c_glo[wl_id]["core_swarm_state_bytes"] == c_loc[wl_id]["core_swarm_state_bytes"]
+ assert c_glo[wl_id]["baseline_core_swarm_state_bytes"] == c_loc[wl_id]["baseline_core_swarm_state_bytes"]
+ assert c_glo[wl_id]["state_ratio"] == c_loc[wl_id]["state_ratio"]
+
+
+def test_invalid_projection_scope_rejection(tmp_path: Path):
+ """Verify invalid projection_scope is rejected before loading datasets."""
+
+ with pytest.raises(ValueError, match="Invalid projection_scope"):
+ run_heavy_pso_autoresearch(projection_scope="invalid_scope", cache_dir=tmp_path)
+
+
+def test_cli_projection_scope_argument_parsing():
+ """Verify CLI parser handles default and explicit --projection-scope flag."""
+ parser = build_parser()
+ args_default = parser.parse_args([])
+ assert args_default.projection_scope == "global"
+
+ args_local = parser.parse_args(["--projection-scope", "tensor_local"])
+ assert args_local.projection_scope == "tensor_local"
+
+
+def test_projection_seed_mode_default_and_coupled_backward_compatibility():
+ """Verify default projection seed mode is 'coupled' and produces exact legacy seeds and candidate IDs."""
+ assert DEFAULT_PROJECTION_SEED_MODE == "coupled"
+ assert PROJECTION_SEED_MODES == ("coupled", "fixed", "explicit")
+
+ # Default derive_projection_seed vs explicit coupled
+ s_default = derive_projection_seed("mnist_compact", 0.5, 101)
+ s_coupled = derive_projection_seed("mnist_compact", 0.5, 101, mode="coupled")
+ s_coupled_param = derive_projection_seed("mnist_compact", 0.5, 101, projection_seed_mode="coupled")
+ assert s_default == s_coupled == s_coupled_param
+
+ # Legacy formula check (empty salt, coupled)
+ key = "mnist_compact:0.50000:101".encode("utf-8")
+ expected_legacy = int(hashlib.sha256(key).hexdigest()[:8], 16) % (2**31 - 1)
+ assert s_default == expected_legacy
+
+ # Candidate ID default format_ratio_id checks
+ assert format_ratio_id(0.5) == "r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", "global") == "aligned_r0.5"
+ assert format_ratio_id(0.5, "recovered", "tensor_local") == "local_r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", "tensor_local") == "local_aligned_r0.5"
+
+
+def test_fixed_projection_seed_equal_across_swarm_seeds():
+ """Verify fixed projection seed mode produces identical seeds across swarm seeds (101, 102, 103)."""
+ s101 = derive_projection_seed("mnist_compact", 0.5, 101, mode="fixed")
+ s102 = derive_projection_seed("mnist_compact", 0.5, 102, mode="fixed")
+ s103 = derive_projection_seed("mnist_compact", 0.5, 103, mode="fixed")
+ assert s101 == s102 == s103, "Fixed mode projection seed must be identical across swarm seeds"
+
+
+def test_fixed_projection_seed_variation_across_workload_ratio_salt():
+ """Verify fixed projection seed mode varies across workload, ratio, and salt."""
+ s_base = derive_projection_seed("mnist_compact", 0.5, 101, mode="fixed")
+ s_diff_wl = derive_projection_seed("mnist_wide", 0.5, 101, mode="fixed")
+ s_diff_ratio = derive_projection_seed("mnist_compact", 0.25, 101, mode="fixed")
+ s_salted = derive_projection_seed("mnist_compact", 0.5, 101, projection_salt="replica-1", mode="fixed")
+
+ assert s_base != s_diff_wl, "Fixed projection seed must vary by workload"
+ assert s_base != s_diff_ratio, "Fixed projection seed must vary by ratio"
+ assert s_base != s_salted, "Fixed projection seed must vary by salt"
+
+
+def test_invalid_projection_seed_mode_rejection(tmp_path: Path):
+ """Verify invalid projection_seed_mode is rejected early before loading datasets and in derivation."""
+ import pytest
+ with pytest.raises(ValueError, match="Invalid projection_seed_mode"):
+ derive_projection_seed("mnist_compact", 0.5, 101, mode="invalid_mode")
+
+ with pytest.raises(ValueError, match="Invalid projection_seed_mode"):
+ run_heavy_pso_autoresearch(projection_seed_mode="invalid_mode", cache_dir=tmp_path)
+
+
+def test_format_ratio_id_projection_seed_mode_prefix_combinations():
+ """Verify format_ratio_id produces exact prefix combinations for policy, scope, and seed mode."""
+ # Coupled (default) mode
+ assert format_ratio_id(0.125, "recovered", "global", "coupled") == "r0.125"
+ assert format_ratio_id(0.125, "baseline_aligned", "global", "coupled") == "aligned_r0.125"
+ assert format_ratio_id(0.125, "recovered", "tensor_local", "coupled") == "local_r0.125"
+ assert format_ratio_id(0.125, "baseline_aligned", "tensor_local", "coupled") == "local_aligned_r0.125"
+
+ # Fixed mode
+ assert format_ratio_id(0.125, "recovered", "global", "fixed") == "fixed_r0.125"
+ assert format_ratio_id(0.125, "baseline_aligned", "global", "fixed") == "fixed_aligned_r0.125"
+ assert format_ratio_id(0.125, "recovered", "tensor_local", "fixed") == "fixed_local_r0.125"
+ assert format_ratio_id(0.125, "baseline_aligned", "tensor_local", "fixed") == "fixed_local_aligned_r0.125"
+
+
+def test_cli_projection_seed_mode_argument_parsing():
+ """Verify CLI parser handles default and explicit --projection-seed-mode flag."""
+ parser = build_parser()
+ args_default = parser.parse_args([])
+ assert args_default.projection_seed_mode == "coupled"
+
+ args_fixed = parser.parse_args(["--projection-seed-mode", "fixed"])
+ assert args_fixed.projection_seed_mode == "fixed"
+
+
+def test_projection_seed_mode_runner_provenance_and_persistence(monkeypatch, tmp_path: Path):
+ """Verify projection_seed_mode='fixed' is persisted at experiment, workload, candidate, and per-seed levels."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ payload = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102, 103],
+ geometry_policy="recovered",
+ projection_scope="global",
+ projection_seed_mode="fixed",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert payload["experiment_config"]["projection_seed_mode"] == "fixed"
+ assert payload["workloads"]["mnist_compact"]["projection_seed_mode"] == "fixed"
+ assert "fixed_r0.5" in payload["candidate_runs"]
+
+ cand_rec = payload["candidate_runs"]["fixed_r0.5"]["mnist_compact"]
+ assert cand_rec["projection_seed_mode"] == "fixed"
+ assert cand_rec["candidate_id"] == "fixed_r0.5"
+
+ seed_runs = cand_rec["per_seed_runs"]
+ assert len(seed_runs) == 3
+ for s_rec in seed_runs:
+ assert s_rec["projection_seed_mode"] == "fixed"
+
+ # All swarm seeds must have the exact same projection_seed in fixed mode
+ p_seeds = [s_rec["projection_seed"] for s_rec in seed_runs]
+ assert len(set(p_seeds)) == 1, f"Expected single fixed projection_seed across seeds, got {p_seeds}"
+
+
+def test_projection_seed_mode_exact_accounting_unchanged(monkeypatch, tmp_path: Path):
+ """Verify projection_seed_mode='fixed' preserves total queries, samples, state bytes, and baseline bytes."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ payload_coupled = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ projection_seed_mode="coupled",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ payload_fixed = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ projection_seed_mode="fixed",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ cfg_c = payload_coupled["experiment_config"]
+ cfg_f = payload_fixed["experiment_config"]
+ assert cfg_c["total_runs"] == cfg_f["total_runs"]
+ assert cfg_c["total_queries"] == cfg_f["total_queries"]
+ assert cfg_c["total_sample_evaluations"] == cfg_f["total_sample_evaluations"]
+
+ for c_coup, c_fix in zip(payload_coupled["candidate_runs"].values(), payload_fixed["candidate_runs"].values()):
+ for wl_id in c_coup:
+ assert c_coup[wl_id]["core_swarm_state_bytes"] == c_fix[wl_id]["core_swarm_state_bytes"]
+ assert c_coup[wl_id]["baseline_core_swarm_state_bytes"] == c_fix[wl_id]["baseline_core_swarm_state_bytes"]
+ assert c_coup[wl_id]["state_ratio"] == c_fix[wl_id]["state_ratio"]
+ assert c_coup[wl_id]["latent_dim"] == c_fix[wl_id]["latent_dim"]
+ assert c_coup[wl_id]["total_dim"] == c_fix[wl_id]["total_dim"]
+
+
+def test_fixed_global_baseline_aligned_matrix_evaluator_schema_and_seeds(monkeypatch, tmp_path: Path):
+ """Verify fixed/global/baseline-aligned matrix retains evaluator schema and has identical projection_seed for seeds 101-103 within each workload-ratio cell."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ payload = run_heavy_pso_autoresearch(
+ ratios=[0.5, 0.25],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102, 103],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ projection_seed_mode="fixed",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ # Check candidate IDs
+ assert set(payload["candidate_runs"].keys()) == {"fixed_aligned_r0.5", "fixed_aligned_r0.25"}
+
+ # Check that within each candidate and workload cell, seeds 101-103 share 1 projection_seed
+ for cand_id, wl_candidates in payload["candidate_runs"].items():
+ for wl_id, wl_data in wl_candidates.items():
+ per_seed = wl_data["per_seed_runs"]
+ assert len(per_seed) == 3
+ proj_seeds = [rec["projection_seed"] for rec in per_seed]
+ assert len(set(proj_seeds)) == 1, f"Expected 1 projection seed for {cand_id}/{wl_id}, got {proj_seeds}"
+
+ # Evaluate mock payload with evaluate_heavy_autoresearch to ensure evaluator schema compatibility
+ cand_file = tmp_path / "candidate_fixed_matrix.json"
+ with open(cand_file, "w", encoding="utf-8") as f:
+ json.dump(payload, f)
+
+ base_file = create_mock_baseline_json(tmp_path)
+ eval_res = evaluate_heavy_autoresearch(base_file, cand_file)
+ assert isinstance(eval_res["pass"], bool)
+ assert isinstance(eval_res["score"], float)
+ assert set(eval_res["candidate_evaluations"]) == set(payload["candidate_runs"])
+
+
+def test_explicit_projection_seed_validations(tmp_path: Path):
+ """Verify explicit projection seed mode validation checks for missing, negative, out-of-range, and supplied non-explicit seeds."""
+ # Missing seed in explicit mode
+ with pytest.raises(ValueError, match="projection_seed must be provided when projection_seed_mode is 'explicit'"):
+ validate_projection_seed_config("explicit", None)
+
+ with pytest.raises(ValueError, match="projection_seed must be provided when projection_seed_mode is 'explicit'"):
+ derive_projection_seed("mnist_wide", 0.5, 101, mode="explicit", projection_seed=None)
+
+ # Negative seed
+ with pytest.raises(ValueError, match="projection_seed must be a non-negative integer"):
+ validate_projection_seed_config("explicit", -1)
+
+ with pytest.raises(ValueError, match="projection_seed must be a non-negative integer"):
+ derive_projection_seed("mnist_wide", 0.5, 101, mode="explicit", projection_seed=-10)
+
+ # Out-of-range seed >= 2**31 - 1
+ max_seed = 2**31 - 1 # 2147483647
+ with pytest.raises(ValueError, match="projection_seed must be a non-negative integer"):
+ validate_projection_seed_config("explicit", max_seed)
+
+ with pytest.raises(ValueError, match="projection_seed must be a non-negative integer"):
+ derive_projection_seed("mnist_wide", 0.5, 101, mode="explicit", projection_seed=2**31)
+
+ # Non-integer types (float, bool)
+ with pytest.raises(ValueError, match="projection_seed must be a non-negative integer"):
+ validate_projection_seed_config("explicit", 592157828.0)
+
+ with pytest.raises(ValueError, match="projection_seed must be a non-negative integer"):
+ validate_projection_seed_config("explicit", True)
+
+ # Seed supplied to coupled/fixed modes
+ with pytest.raises(ValueError, match="projection_seed can only be provided when projection_seed_mode is 'explicit'"):
+ validate_projection_seed_config("coupled", 592157828)
+
+ with pytest.raises(ValueError, match="projection_seed can only be provided when projection_seed_mode is 'explicit'"):
+ validate_projection_seed_config("fixed", 592157828)
+
+ with pytest.raises(ValueError, match="projection_seed can only be provided when projection_seed_mode is 'explicit'"):
+ derive_projection_seed("mnist_wide", 0.5, 101, mode="coupled", projection_seed=592157828)
+
+ # Validate rejection occurs before data loading in runner
+ with pytest.raises(ValueError, match="projection_seed must be provided when projection_seed_mode is 'explicit'"):
+ run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ projection_seed_mode="explicit",
+ projection_seed=None,
+ cache_dir=tmp_path,
+ )
+
+ with pytest.raises(ValueError, match="projection_seed can only be provided when projection_seed_mode is 'explicit'"):
+ run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ projection_seed_mode="coupled",
+ projection_seed=592157828,
+ cache_dir=tmp_path,
+ )
+
+def test_explicit_projection_seed_dict_validations(tmp_path: Path):
+ """Verify dictionary explicit projection seeds require exactly WORKLOADS keys, rejecting partial and extra dicts."""
+ valid_dict = {
+ "mnist_compact": 101,
+ "mnist_wide": 102,
+ "fashion_compact": 103,
+ "fashion_wide": 104,
+ }
+ # Complete dict remains accepted
+ validate_projection_seed_config("explicit", valid_dict)
+ assert derive_projection_seed("mnist_compact", 0.5, 101, mode="explicit", projection_seed=valid_dict) == 101
+ assert derive_projection_seed("mnist_wide", 0.5, 101, mode="explicit", projection_seed=valid_dict) == 102
+
+ # Partial dict missing required keys fails immediately
+ partial_dict = {"mnist_compact": 101, "mnist_wide": 102}
+ with pytest.raises(ValueError, match="missing required workload key"):
+ validate_projection_seed_config("explicit", partial_dict)
+
+ with pytest.raises(ValueError, match="missing required workload key"):
+ derive_projection_seed("mnist_compact", 0.5, 101, mode="explicit", projection_seed=partial_dict)
+
+ with pytest.raises(ValueError, match="missing required workload key"):
+ run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ projection_seed_mode="explicit",
+ projection_seed=partial_dict,
+ cache_dir=tmp_path,
+ )
+
+ # Extra dict with unknown keys fails immediately
+ extra_dict = {
+ "mnist_compact": 101,
+ "mnist_wide": 102,
+ "fashion_compact": 103,
+ "fashion_wide": 104,
+ "unknown_workload": 105,
+ }
+ with pytest.raises(ValueError, match="Unknown workload_id key"):
+ validate_projection_seed_config("explicit", extra_dict)
+
+ with pytest.raises(ValueError, match="Unknown workload_id key"):
+ derive_projection_seed("mnist_compact", 0.5, 101, mode="explicit", projection_seed=extra_dict)
+
+ with pytest.raises(ValueError, match="Unknown workload_id key"):
+ run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ projection_seed_mode="explicit",
+ projection_seed=extra_dict,
+ cache_dir=tmp_path,
+ )
+ # Both missing and unknown keys in dict
+ mixed_invalid_dict = {"mnist_compact": 101, "extra_key": 105}
+ with pytest.raises(ValueError, match="missing required workload key.*Unknown workload_id key"):
+ validate_projection_seed_config("explicit", mixed_invalid_dict)
+
+
+def test_parse_projection_seed_arg():
+ """Verify parse_projection_seed_arg handles scalar integers, JSON dicts, key-value strings, and raises narrow exceptions on invalid forms."""
+ # Scalar integers and int strings
+ assert parse_projection_seed_arg(42) == 42
+ assert parse_projection_seed_arg("42") == 42
+ assert parse_projection_seed_arg(None) is None
+ assert parse_projection_seed_arg("None") is None
+
+ # JSON dict strings
+ json_str = '{"mnist_compact": 101, "mnist_wide": 102, "fashion_compact": 103, "fashion_wide": 104}'
+ parsed_json = parse_projection_seed_arg(json_str)
+ assert isinstance(parsed_json, dict)
+ assert parsed_json["mnist_compact"] == 101
+
+ # Key-value strings
+ kv_str = "mnist_compact:101,mnist_wide:102,fashion_compact:103,fashion_wide:104"
+ parsed_kv = parse_projection_seed_arg(kv_str)
+ assert isinstance(parsed_kv, dict)
+ assert parsed_kv["mnist_wide"] == 102
+
+ # Malformed JSON starting with { and ending with } raises ValueError from narrow exception handling
+ with pytest.raises(ValueError, match="Failed to parse projection_seed JSON dict string"):
+ parse_projection_seed_arg("{invalid_json_format}")
+
+ with pytest.raises(ValueError, match="Failed to parse projection_seed JSON dict string"):
+ parse_projection_seed_arg('{"mnist_compact": "not_an_int"}')
+
+ # Unparseable string
+ with pytest.raises(ValueError, match="Cannot parse projection_seed value"):
+ parse_projection_seed_arg("not_a_number_or_dict")
+
+def test_explicit_projection_seed_derivation():
+ """Verify derive_projection_seed returns the exact explicit value regardless of workload, ratio, swarm seed, or salt."""
+ seed1 = derive_projection_seed(
+ "mnist_wide", 0.5, 101, projection_salt="", mode="explicit", projection_seed=592157828
+ )
+ assert seed1 == 592157828
+
+ seed2 = derive_projection_seed(
+ "fashion_compact", 0.03125, 103, projection_salt="salt_test", mode="explicit", projection_seed=592157828
+ )
+ assert seed2 == 592157828
+
+ seed3 = derive_projection_seed(
+ "mnist_compact", 0.25, 102, projection_salt="", mode="explicit", projection_seed=820515361
+ )
+ assert seed3 == 820515361
+
+
+def test_explicit_format_ratio_id_prefix_ordering():
+ """Verify format_ratio_id prepends p_ before optional local_ and existing base ID across combinations."""
+ # explicit global baseline_aligned
+ assert format_ratio_id(0.5, "baseline_aligned", "global", "explicit", 592157828) == "p592157828_aligned_r0.5"
+ # explicit tensor_local baseline_aligned
+ assert format_ratio_id(0.5, "baseline_aligned", "tensor_local", "explicit", 592157828) == "p592157828_local_aligned_r0.5"
+ # explicit global recovered
+ assert format_ratio_id(0.5, "recovered", "global", "explicit", 592157828) == "p592157828_r0.5"
+ # explicit tensor_local recovered
+ assert format_ratio_id(0.5, "recovered", "tensor_local", "explicit", 592157828) == "p592157828_local_r0.5"
+ # explicit ratio 0.03125
+ assert format_ratio_id(0.03125, "baseline_aligned", "global", "explicit", 820515361) == "p820515361_aligned_r0.03125"
+
+
+def test_cli_explicit_projection_seed_argument_parsing():
+ """Verify CLI parser handles --projection-seed-mode explicit and --projection-seed flags."""
+ parser = build_parser()
+ args1 = parser.parse_args(["--projection-seed-mode", "explicit", "--projection-seed", "592157828"])
+ assert args1.projection_seed_mode == "explicit"
+ assert args1.projection_seed == 592157828
+
+ args2 = parser.parse_args(["--projection-seed-mode", "explicit", "--projection-seed", "820515361"])
+ assert args2.projection_seed_mode == "explicit"
+ assert args2.projection_seed == 820515361
+
+
+def test_explicit_runner_provenance_and_persistence(monkeypatch, tmp_path: Path):
+ """Verify explicit mode and projection seed are persisted at experiment, workload, candidate, and per-seed levels."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ payload = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ projection_seed_mode="explicit",
+ projection_seed=592157828,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ # Check top-level experiment_config
+ exp_cfg = payload["experiment_config"]
+ assert exp_cfg["projection_seed_mode"] == "explicit"
+ assert exp_cfg["projection_seed"] == 592157828
+
+ # Check workloads provenance
+ for wl_id, wl_meta in payload["workloads"].items():
+ assert wl_meta["projection_seed_mode"] == "explicit"
+ assert wl_meta["projection_seed"] == 592157828
+
+ # Check candidate_runs
+ cand_dict = payload["candidate_runs"]["p592157828_aligned_r0.5"]
+ for wl_id, wl_cand in cand_dict.items():
+ assert wl_cand["candidate_id"] == "p592157828_aligned_r0.5"
+ assert wl_cand["projection_seed_mode"] == "explicit"
+ assert wl_cand["projection_seed"] == 592157828
+
+ for seed_rec in wl_cand["per_seed_runs"]:
+ assert seed_rec["projection_seed_mode"] == "explicit"
+ assert seed_rec["projection_seed"] == 592157828
+
+
+def test_explicit_projection_seed_no_change_to_query_and_sample_accounting(monkeypatch, tmp_path: Path):
+ """Verify explicit projection seed mode preserves total queries, samples, state bytes, and baseline bytes."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ payload_coupled = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102, 103],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ projection_seed_mode="coupled",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ payload_explicit = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102, 103],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ projection_seed_mode="explicit",
+ projection_seed=592157828,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ cfg_c = payload_coupled["experiment_config"]
+ cfg_e = payload_explicit["experiment_config"]
+
+ assert cfg_c["total_runs"] == cfg_e["total_runs"]
+ assert cfg_c["total_queries"] == cfg_e["total_queries"]
+ assert cfg_c["total_sample_evaluations"] == cfg_e["total_sample_evaluations"]
+
+ c_coup = payload_coupled["candidate_runs"]["aligned_r0.5"]
+ c_exp = payload_explicit["candidate_runs"]["p592157828_aligned_r0.5"]
+
+ for wl_id in ["mnist_compact", "mnist_wide", "fashion_compact", "fashion_wide"]:
+ assert c_coup[wl_id]["latent_dim"] == c_exp[wl_id]["latent_dim"]
+ assert c_coup[wl_id]["total_dim"] == c_exp[wl_id]["total_dim"]
+ assert c_coup[wl_id]["core_swarm_state_bytes"] == c_exp[wl_id]["core_swarm_state_bytes"]
+ assert c_coup[wl_id]["baseline_core_swarm_state_bytes"] == c_exp[wl_id]["baseline_core_swarm_state_bytes"]
+ assert c_coup[wl_id]["state_ratio"] == c_exp[wl_id]["state_ratio"]
+
+
+def test_explicit_matched_elites_confirmation_runs(monkeypatch, tmp_path: Path):
+ """Verify two separate matched runner invocations can confirm seed 592157828 at ratio 0.5 and seed 820515361 at ratio 0.03125 across all 4 workloads and seeds 101-103."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ # Elite 1: seed 592157828 at ratio 0.5
+ run1 = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102, 103],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ projection_seed_mode="explicit",
+ projection_seed=592157828,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert "p592157828_aligned_r0.5" in run1["candidate_runs"]
+ cand1 = run1["candidate_runs"]["p592157828_aligned_r0.5"]
+ assert len(cand1) == 4
+ for wl_id, wl_data in cand1.items():
+ assert len(wl_data["per_seed_runs"]) == 3
+ for r_entry in wl_data["per_seed_runs"]:
+ assert r_entry["projection_seed"] == 592157828
+ assert r_entry["projection_seed_mode"] == "explicit"
+
+ # Elite 2: seed 820515361 at ratio 0.03125
+ run2 = run_heavy_pso_autoresearch(
+ ratios=[0.03125],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102, 103],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ projection_seed_mode="explicit",
+ projection_seed=820515361,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert "p820515361_aligned_r0.03125" in run2["candidate_runs"]
+ cand2 = run2["candidate_runs"]["p820515361_aligned_r0.03125"]
+ assert len(cand2) == 4
+ for wl_id, wl_data in cand2.items():
+ assert len(wl_data["per_seed_runs"]) == 3
+ for r_entry in wl_data["per_seed_runs"]:
+ assert r_entry["projection_seed"] == 820515361
+ assert r_entry["projection_seed_mode"] == "explicit"
+
+ # Evaluate mock artifacts with evaluator to confirm schema compatibility
+ f1 = tmp_path / "cand1.json"
+ with open(f1, "w", encoding="utf-8") as f:
+ json.dump(run1, f)
+ base_file = create_mock_baseline_json(tmp_path)
+ res1 = evaluate_heavy_autoresearch(base_file, f1)
+ assert isinstance(res1["pass"], bool)
+ assert isinstance(res1["score"], float)
+
+ f2 = tmp_path / "cand2.json"
+ with open(f2, "w", encoding="utf-8") as f:
+ json.dump(run2, f)
+ res2 = evaluate_heavy_autoresearch(base_file, f2)
+ assert isinstance(res2["pass"], bool)
+ assert isinstance(res2["score"], float)
+
+
+def test_geometry_multiplier_exact_scaling():
+ """Verify geometry_multiplier uniformly scales position_radius, initial_velocity_radius, reset_velocity_radius, and reflective_bound."""
+ geom_table = get_v6_geometry_table()
+ base_g6 = geom_table["G6"]
+ total_dim = 9098
+ latent_dim = compute_latent_dim(total_dim, 0.5)
+ scale_factor = math.sqrt(total_dim / latent_dim)
+
+ # Multiplier 1.0 (default)
+ eq_g6_1 = construct_equalized_geometry(base_g6, total_dim, latent_dim, projection_seed=42, ratio_str="r0.5", geometry_multiplier=1.0)
+ assert math.isclose(eq_g6_1.position_radius, base_g6.position_radius * scale_factor)
+ assert math.isclose(eq_g6_1.initial_velocity_radius, base_g6.initial_velocity_radius * scale_factor)
+ assert math.isclose(eq_g6_1.reset_velocity_radius, base_g6.reset_velocity_radius * scale_factor)
+ assert math.isclose(eq_g6_1.reflective_bound, base_g6.reflective_bound * scale_factor)
+
+ # Multiplier 0.75
+ eq_g6_075 = construct_equalized_geometry(base_g6, total_dim, latent_dim, projection_seed=42, ratio_str="g0.75_r0.5", geometry_multiplier=0.75)
+ assert math.isclose(eq_g6_075.position_radius, base_g6.position_radius * scale_factor * 0.75)
+ assert math.isclose(eq_g6_075.initial_velocity_radius, base_g6.initial_velocity_radius * scale_factor * 0.75)
+ assert math.isclose(eq_g6_075.reset_velocity_radius, base_g6.reset_velocity_radius * scale_factor * 0.75)
+ assert math.isclose(eq_g6_075.reflective_bound, base_g6.reflective_bound * scale_factor * 0.75)
+
+ # Multiplier 0.5
+ eq_g6_05 = construct_equalized_geometry(base_g6, total_dim, latent_dim, projection_seed=42, ratio_str="g0.5_r0.5", geometry_multiplier=0.5)
+ assert math.isclose(eq_g6_05.position_radius, base_g6.position_radius * scale_factor * 0.5)
+ assert math.isclose(eq_g6_05.initial_velocity_radius, base_g6.initial_velocity_radius * scale_factor * 0.5)
+ assert math.isclose(eq_g6_05.reset_velocity_radius, base_g6.reset_velocity_radius * scale_factor * 0.5)
+ assert math.isclose(eq_g6_05.reflective_bound, base_g6.reflective_bound * scale_factor * 0.5)
+
+ # Invariant attributes remain unchanged
+ for eq_geom in (eq_g6_1, eq_g6_075, eq_g6_05):
+ assert eq_geom.mutation_prob == base_g6.mutation_prob
+ assert eq_geom.scale_type == base_g6.scale_type
+ assert eq_geom.init_position_mode == base_g6.init_position_mode
+ assert eq_geom.latent_dim == latent_dim
+ assert eq_geom.projection_seed == 42
+
+
+def test_geometry_multiplier_validations(tmp_path: Path):
+ """Verify geometry_multiplier rejects non-numeric, non-finite, zero, or negative inputs with ValueError."""
+ invalid_multipliers = [
+ 0,
+ 0.0,
+ -0.5,
+ -1.0,
+ float("nan"),
+ float("inf"),
+ float("-inf"),
+ "0.75",
+ True,
+ False,
+ None,
+ ]
+ geom_table = get_v6_geometry_table()
+ base_g6 = geom_table["G6"]
+
+ for inv in invalid_multipliers:
+ with pytest.raises(ValueError, match="geometry_multiplier must be a finite positive float"):
+ validate_geometry_multiplier(inv)
+
+ with pytest.raises(ValueError, match="geometry_multiplier must be a finite positive float"):
+ format_ratio_id(0.5, geometry_multiplier=inv)
+
+ with pytest.raises(ValueError, match="geometry_multiplier must be a finite positive float"):
+ construct_equalized_geometry(base_g6, 9098, 4549, projection_seed=42, geometry_multiplier=inv)
+
+ with pytest.raises(ValueError, match="geometry_multiplier must be a finite positive float"):
+ run_heavy_pso_autoresearch(geometry_multiplier=inv, cache_dir=tmp_path)
+
+
+def test_format_ratio_id_geometry_multiplier_prefix_and_ordering():
+ """Verify format_ratio_id prepends g_ before all other projection prefixes when geometry_multiplier != 1.0, and leaves default IDs unchanged."""
+ # Default 1.0 multiplier preserves legacy IDs
+ assert format_ratio_id(0.5) == "r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned") == "aligned_r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", "tensor_local") == "local_aligned_r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", "global", "explicit", 592157828) == "p592157828_aligned_r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", "tensor_local", "explicit", 592157828) == "p592157828_local_aligned_r0.5"
+
+ # Multiplier 0.75 prepends g0.75_ at the very front
+ assert format_ratio_id(0.5, geometry_multiplier=0.75) == "g0.75_r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", geometry_multiplier=0.75) == "g0.75_aligned_r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", "tensor_local", geometry_multiplier=0.75) == "g0.75_local_aligned_r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", "global", "explicit", 592157828, geometry_multiplier=0.75) == "g0.75_p592157828_aligned_r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", "tensor_local", "explicit", 592157828, geometry_multiplier=0.75) == "g0.75_p592157828_local_aligned_r0.5"
+
+ # Multiplier 0.5 prepends g0.5_ at the very front
+ assert format_ratio_id(0.5, geometry_multiplier=0.5) == "g0.5_r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", "global", "explicit", 592157828, geometry_multiplier=0.5) == "g0.5_p592157828_aligned_r0.5"
+ assert format_ratio_id(0.5, "baseline_aligned", "tensor_local", "explicit", 592157828, geometry_multiplier=0.5) == "g0.5_p592157828_local_aligned_r0.5"
+
+
+def test_cli_geometry_multiplier_argument_parsing():
+ """Verify CLI parser handles default and explicit --geometry-multiplier flags."""
+ parser = build_parser()
+
+ args_def = parser.parse_args([])
+ assert args_def.geometry_multiplier == 1.0
+
+ args_075 = parser.parse_args(["--geometry-multiplier", "0.75"])
+ assert args_075.geometry_multiplier == 0.75
+
+ args_05 = parser.parse_args(["--geometry-multiplier", "0.5"])
+ assert args_05.geometry_multiplier == 0.5
+
+
+def test_geometry_multiplier_runner_provenance_and_persistence(monkeypatch, tmp_path: Path):
+ """Verify geometry_multiplier is persisted at experiment_config, workloads, candidate_runs, and per_seed_runs levels."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ res = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ projection_seed_mode="explicit",
+ projection_seed=592157828,
+ geometry_multiplier=0.75,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ # 1. Experiment level
+ assert res["experiment_config"]["geometry_multiplier"] == 0.75
+
+ # 2. Workload level
+ for wl_id in EXPECTED_WORKLOADS:
+ assert res["workloads"][wl_id]["geometry_multiplier"] == 0.75
+
+ # 3. Candidate level
+ cand_id = "g0.75_p592157828_aligned_r0.5"
+ assert cand_id in res["candidate_runs"]
+ cand_entry = res["candidate_runs"][cand_id]
+ for wl_id in EXPECTED_WORKLOADS:
+ assert cand_entry[wl_id]["geometry_multiplier"] == 0.75
+
+ # 4. Per-seed level
+ for seed_rec in cand_entry[wl_id]["per_seed_runs"]:
+ assert seed_rec["geometry_multiplier"] == 0.75
+
+
+def test_geometry_multiplier_unchanged_accounting(monkeypatch, tmp_path: Path):
+ """Verify geometry_multiplier preserves total queries, samples, state bytes, baseline bytes, and dimension accounting."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ kwargs = dict(
+ ratios=[0.5],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ projection_seed_mode="explicit",
+ projection_seed=592157828,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ res_default = run_heavy_pso_autoresearch(geometry_multiplier=1.0, **kwargs)
+ res_mult = run_heavy_pso_autoresearch(geometry_multiplier=0.75, **kwargs)
+
+ assert res_default["experiment_config"]["total_queries"] == res_mult["experiment_config"]["total_queries"]
+ assert res_default["experiment_config"]["total_sample_evaluations"] == res_mult["experiment_config"]["total_sample_evaluations"]
+
+ cand_def = res_default["candidate_runs"]["p592157828_aligned_r0.5"]
+ cand_mult = res_mult["candidate_runs"]["g0.75_p592157828_aligned_r0.5"]
+
+ for wl_id in EXPECTED_WORKLOADS:
+ assert cand_def[wl_id]["total_dim"] == cand_mult[wl_id]["total_dim"]
+ assert cand_def[wl_id]["latent_dim"] == cand_mult[wl_id]["latent_dim"]
+ assert cand_def[wl_id]["state_ratio"] == cand_mult[wl_id]["state_ratio"]
+ assert cand_def[wl_id]["core_swarm_state_bytes"] == cand_mult[wl_id]["core_swarm_state_bytes"]
+ assert cand_def[wl_id]["baseline_core_swarm_state_bytes"] == cand_mult[wl_id]["baseline_core_swarm_state_bytes"]
+
+
+def test_explicit_projection_seed_multiplier_elites_confirmation_runs(monkeypatch, tmp_path: Path):
+ """Verify explicit seed 592157828 ratio 0.5 can run at multipliers 0.75 and 0.5 under the matched evaluator schema."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ base_file = create_mock_baseline_json(tmp_path)
+
+ for mult in (0.75, 0.5):
+ cand_run = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102, 103],
+ geometry_policy="baseline_aligned",
+ projection_scope="global",
+ projection_seed_mode="explicit",
+ projection_seed=592157828,
+ geometry_multiplier=mult,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ expected_cand_id = f"g{mult:g}_p592157828_aligned_r0.5"
+ assert expected_cand_id in cand_run["candidate_runs"]
+
+ cand_file = tmp_path / f"cand_mult_{mult}.json"
+ with open(cand_file, "w", encoding="utf-8") as f:
+ json.dump(cand_run, f)
+
+ eval_res = evaluate_heavy_autoresearch(base_file, cand_file)
+ assert isinstance(eval_res["pass"], bool)
+ assert isinstance(eval_res["score"], float)
+ assert eval_res["evaluator_version"] == EVALUATOR_VERSION
+ assert expected_cand_id in eval_res["candidate_evaluations"]
+ assert isinstance(eval_res["candidate_evaluations"][expected_cand_id]["gate_details"]["gate_config_matched"], bool)
+def test_balanced_global_latent_transform_occupancy_balance():
+ """Verify BalancedGlobalLatentTransform produces occupancy differing by at most one and valid weights."""
+ base_model = nn.Sequential(nn.Linear(100, 50), nn.ReLU(), nn.Linear(50, 10))
+ total_dim = sum(p.numel() for p in base_model.parameters())
+ latent_dim = 2780
+
+ geom_cfg = V6GeometryConfig(
+ config_id="test_balanced",
+ projection_seed=12345,
+ latent_dim=latent_dim,
+ )
+ transform = BalancedGlobalLatentTransform(base_model, geom_cfg, torch.device("cpu"))
+ assert transform.is_full is False
+ k_indices = transform.k_indices.cpu().numpy()
+ weights = transform.weights.cpu().numpy()
+
+ bin_counts = np.bincount(k_indices, minlength=latent_dim)
+ assert bin_counts.max() - bin_counts.min() <= 1, "Bucket occupancies must differ by at most 1"
+ assert len(weights) == total_dim
+ assert np.all(np.isfinite(weights))
+
+
+def test_balanced_global_seed_reproducibility_and_variation():
+ """Verify BalancedGlobalLatentTransform reproduces identically for same seed and varies for different seed."""
+ base_model = nn.Sequential(nn.Linear(50, 20), nn.ReLU(), nn.Linear(20, 5))
+
+ geom_cfg1 = V6GeometryConfig(config_id="g1", projection_seed=42, latent_dim=100)
+ geom_cfg2 = V6GeometryConfig(config_id="g2", projection_seed=42, latent_dim=100)
+ geom_cfg3 = V6GeometryConfig(config_id="g3", projection_seed=43, latent_dim=100)
+
+ t1 = BalancedGlobalLatentTransform(base_model, geom_cfg1, torch.device("cpu"))
+ t2 = BalancedGlobalLatentTransform(base_model, geom_cfg2, torch.device("cpu"))
+ t3 = BalancedGlobalLatentTransform(base_model, geom_cfg3, torch.device("cpu"))
+
+ assert torch.equal(t1.k_indices, t2.k_indices)
+ assert torch.equal(t1.weights, t2.weights)
+
+ assert not torch.equal(t1.k_indices, t3.k_indices) or not torch.equal(t1.weights, t3.weights)
+
+
+def test_projection_scope_parsing_and_validation():
+ """Verify projection scope parsing and validation for strings and workload dictionaries."""
+ # Parsing
+ assert parse_projection_scope_arg("global") == "global"
+ assert parse_projection_scope_arg("balanced_global") == "balanced_global"
+ dict_str = '{"mnist_compact": "global", "mnist_wide": "balanced_global", "fashion_compact": "global", "fashion_wide": "balanced_global"}'
+ parsed = parse_projection_scope_arg(dict_str)
+ assert parsed["mnist_wide"] == "balanced_global"
+
+ kv_str = "mnist_compact:global,mnist_wide:balanced_global,fashion_compact:global,fashion_wide:balanced_global"
+ parsed_kv = parse_projection_scope_arg(kv_str)
+ assert parsed_kv["mnist_wide"] == "balanced_global"
+
+ # Validation
+ validate_projection_scope_config("global")
+ validate_projection_scope_config("tensor_local")
+ validate_projection_scope_config("balanced_global")
+ validate_projection_scope_config("adjacent_difference")
+ mixed_dict = {
+ "mnist_compact": "global",
+ "mnist_wide": "balanced_global",
+ "fashion_compact": "global",
+ "fashion_wide": "balanced_global",
+ }
+ validate_projection_scope_config(mixed_dict)
+
+ with pytest.raises(ValueError, match="Invalid projection_scope"):
+ validate_projection_scope_config("unknown_scope")
+
+ with pytest.raises(ValueError, match="missing keys"):
+ validate_projection_scope_config({"mnist_compact": "global"})
+
+ with pytest.raises(ValueError, match="unknown keys"):
+ validate_projection_scope_config({
+ "mnist_compact": "global",
+ "mnist_wide": "balanced_global",
+ "fashion_compact": "global",
+ "fashion_wide": "balanced_global",
+ "extra_key": "global",
+ })
+
+ with pytest.raises(ValueError, match="Invalid projection_scope"):
+ validate_projection_scope_config({
+ "mnist_compact": "global",
+ "mnist_wide": "invalid_scope",
+ "fashion_compact": "global",
+ "fashion_wide": "balanced_global",
+ })
+
+
+def test_mixed_projection_scope_transform_selection_and_candidate_id(monkeypatch, tmp_path: Path):
+ """Verify mixed scope dict candidate ID formatting and transform selection/serialization."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ mixed_scope = {
+ "mnist_compact": "global",
+ "mnist_wide": "balanced_global",
+ "fashion_compact": "global",
+ "fashion_wide": "balanced_global",
+ }
+ projection_seeds = {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 592157828,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 189641451,
+ }
+
+ cand_id = format_ratio_id(
+ 0.5,
+ "baseline_aligned",
+ mixed_scope,
+ "explicit",
+ projection_seeds,
+ )
+ assert cand_id == "pexplicit_mixed_aligned_r0.5"
+
+ payload = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=1,
+ subset_size=10,
+ seeds=[101, 102, 103],
+ geometry_policy="baseline_aligned",
+ projection_scope=mixed_scope,
+ projection_seed_mode="explicit",
+ projection_seed=projection_seeds,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert payload["experiment_config"]["projection_scope"] == mixed_scope
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "global"
+ assert payload["workloads"]["mnist_wide"]["projection_scope"] == "balanced_global"
+
+ cand_runs = payload["candidate_runs"]["pexplicit_mixed_aligned_r0.5"]
+ assert cand_runs["mnist_compact"]["projection_scope"] == "global"
+ assert cand_runs["mnist_wide"]["projection_scope"] == "balanced_global"
+ assert cand_runs["mnist_compact"]["per_seed_runs"][0]["projection_scope"] == "global"
+ assert cand_runs["mnist_wide"]["per_seed_runs"][0]["projection_scope"] == "balanced_global"
+
+
+def test_balanced_global_state_math_unchanged():
+ """Verify state bytes accounting is identical for global, tensor_local, and balanced_global scopes."""
+ bytes_global = compute_core_swarm_state_bytes(12, 4549)
+ bytes_balanced = compute_core_swarm_state_bytes(12, 4549)
+ assert bytes_global == bytes_balanced == 5 * 12 * 4549 * 4
+
+
+def test_two_hash_global_transform_same_seed_reproducibility_and_variation():
+ """Verify TwoHashGlobalLatentTransform is deterministic for identical seeds and varies across seeds."""
+ model = nn.Sequential(nn.Linear(20, 10), nn.Linear(10, 2))
+ geom_table = get_v6_geometry_table()
+ base_geom = geom_table["G6"]
+ total_dim = sum(p.numel() for p in model.parameters())
+ geom_cfg1 = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=15,
+ projection_seed=42,
+ ratio_str="r0.5",
+ )
+ geom_cfg2 = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=15,
+ projection_seed=42,
+ ratio_str="r0.5",
+ )
+ geom_cfg3 = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=15,
+ projection_seed=43,
+ ratio_str="r0.5",
+ )
+ device = torch.device("cpu")
+ t1 = TwoHashGlobalLatentTransform(model, geom_cfg1, device)
+ t2 = TwoHashGlobalLatentTransform(model, geom_cfg2, device)
+ t3 = TwoHashGlobalLatentTransform(model, geom_cfg3, device)
+
+ assert torch.equal(t1.k1_indices, t2.k1_indices)
+ assert torch.allclose(t1.weights1, t2.weights1)
+ assert torch.equal(t1.k2_indices, t2.k2_indices)
+ assert torch.allclose(t1.weights2, t2.weights2)
+
+ Z = torch.randn(5, 15)
+ assert torch.allclose(t1.decode(Z), t2.decode(Z))
+
+ assert not (torch.equal(t1.k1_indices, t3.k1_indices) and torch.equal(t1.k2_indices, t3.k2_indices))
+ assert not torch.allclose(t1.decode(Z), t3.decode(Z))
+
+
+def test_two_hash_global_transform_distinct_coordinates():
+ """Verify TwoHashGlobalLatentTransform assigns distinct coordinates (k1 != k2) when latent_dim > 1."""
+ model = nn.Sequential(nn.Linear(30, 20), nn.Linear(20, 5))
+ geom_table = get_v6_geometry_table()
+ base_geom = geom_table["G5"]
+ total_dim = sum(p.numel() for p in model.parameters())
+ device = torch.device("cpu")
+
+ for d in [2, 10, 50, 100]:
+ geom_cfg = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=d,
+ projection_seed=123,
+ ratio_str=f"d{d}",
+ )
+ transform = TwoHashGlobalLatentTransform(model, geom_cfg, device)
+ assert (transform.k1_indices != transform.k2_indices).all()
+
+
+def test_two_hash_global_transform_finite_weights_and_decode_formula():
+ """Verify TwoHashGlobalLatentTransform weights are finite and decode formula matches math specification."""
+ model = nn.Sequential(nn.Linear(10, 4))
+ geom_table = get_v6_geometry_table()
+ base_geom = geom_table["G6"]
+ total_dim = sum(p.numel() for p in model.parameters())
+ geom_cfg = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=8,
+ projection_seed=999,
+ ratio_str="r0.5",
+ )
+ device = torch.device("cpu")
+ transform = TwoHashGlobalLatentTransform(model, geom_cfg, device)
+
+ assert torch.isfinite(transform.weights1).all()
+ assert torch.isfinite(transform.weights2).all()
+ assert not torch.equal(
+ torch.sign(transform.weights1), torch.sign(transform.weights2)
+ )
+
+ Z = torch.randn(4, 8)
+ decoded = transform.decode(Z)
+ assert decoded.shape == (4, total_dim)
+
+ term1 = Z[:, transform.k1_indices] * transform.weights1
+ term2 = Z[:, transform.k2_indices] * transform.weights2
+ expected_delta = (term1 + term2) / math.sqrt(2.0)
+ expected_decoded = transform.base_vec + transform.scale_vec * expected_delta
+
+ assert torch.allclose(decoded, expected_decoded, atol=1e-6)
+
+
+def test_two_hash_global_full_dimensional_parity():
+ """Verify TwoHashGlobalLatentTransform preserves full-dimensional parity when latent_dim == total_dim."""
+ model = nn.Sequential(nn.Linear(10, 5))
+ geom_table = get_v6_geometry_table()
+ base_geom = geom_table["G6"]
+ total_dim = sum(p.numel() for p in model.parameters())
+ geom_cfg = construct_equalized_geometry(
+ base_geom=base_geom,
+ total_dim=total_dim,
+ latent_dim=total_dim,
+ projection_seed=777,
+ ratio_str="r1.0",
+ )
+ device = torch.device("cpu")
+ transform_two_hash = TwoHashGlobalLatentTransform(model, geom_cfg, device)
+ transform_v6 = V6LatentTransform(model, geom_cfg, device)
+
+ Z = torch.randn(3, total_dim)
+ out_two_hash = transform_two_hash.decode(Z)
+ out_v6 = transform_v6.decode(Z)
+
+ assert torch.allclose(out_two_hash, out_v6)
+
+
+def test_two_hash_global_unchanged_core_state_bytes():
+ """Verify state bytes accounting is identical for two_hash_global, global, and other scopes."""
+ bytes_global = compute_core_swarm_state_bytes(12, 4549)
+ bytes_two_hash = compute_core_swarm_state_bytes(12, 4549)
+ assert bytes_global == bytes_two_hash == 5 * 12 * 4549 * 4
+
+
+def test_two_hash_global_runner_provenance_and_persistence(monkeypatch, tmp_path: Path):
+ """Verify projection_scope='two_hash_global' persists in experiment_config, workloads, candidate_runs, and per_seed_runs."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ payload = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ geometry_policy="baseline_aligned",
+ projection_scope="two_hash_global",
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert payload["experiment_config"]["projection_scope"] == "two_hash_global"
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "two_hash_global"
+ assert "two_hash_aligned_r0.5" in payload["candidate_runs"]
+
+ cand_rec = payload["candidate_runs"]["two_hash_aligned_r0.5"]["mnist_compact"]
+ assert cand_rec["projection_scope"] == "two_hash_global"
+ assert cand_rec["candidate_id"] == "two_hash_aligned_r0.5"
+
+ seed_rec = cand_rec["per_seed_runs"][0]
+ assert seed_rec["projection_scope"] == "two_hash_global"
+
+
+def test_largest_tensor_hash_transform_mapping_and_containment():
+ """Verify LargestTensorHashLatentTransform maps non-largest tensors 1-to-1/direct and largest tensor into residual range."""
+ from heavy_task_feasibility import create_model
+ model = create_model("wide_cnn")
+ param_numels = [p.numel() for p in model.parameters()]
+ total_dim = sum(param_numels)
+ largest_idx = int(np.argmax(param_numels))
+ protected_dim = sum(numel for i, numel in enumerate(param_numels) if i != largest_idx)
+
+ latent_dim = math.ceil(total_dim * 0.5)
+ geom_cfg = V6GeometryConfig(
+ config_id="test_lth_containment",
+ projection_seed=12345,
+ latent_dim=latent_dim,
+ )
+ device = torch.device("cpu")
+ transform = LargestTensorHashLatentTransform(model, geom_cfg, device)
+
+ residual_dim = latent_dim - protected_dim
+ assert protected_dim == 5162
+ assert residual_dim == 22507
+ assert residual_dim > 0
+
+ k_indices = transform.k_indices.cpu().numpy()
+ weights = transform.weights.cpu().numpy()
+
+ j_offset = 0
+ direct_coord = 0
+ for i, numel in enumerate(param_numels):
+ j_slice = slice(j_offset, j_offset + numel)
+ if i != largest_idx:
+ expected_coords = np.arange(direct_coord, direct_coord + numel)
+ assert np.array_equal(k_indices[j_slice], expected_coords)
+ assert np.array_equal(weights[j_slice], np.ones(numel, dtype=np.float32))
+ direct_coord += numel
+ else:
+ assert np.all(k_indices[j_slice] >= protected_dim)
+ assert np.all(k_indices[j_slice] < latent_dim)
+ j_offset += numel
+
+
+def test_largest_tensor_hash_transform_determinism_and_seed_variation():
+ """Verify LargestTensorHashLatentTransform reproduces for same seed and varies only hashed mapping/signs for changed seed."""
+ from heavy_task_feasibility import create_model
+ model = create_model("wide_cnn")
+ param_numels = [p.numel() for p in model.parameters()]
+ largest_idx = int(np.argmax(param_numels))
+ largest_start = sum(param_numels[:largest_idx])
+ largest_end = largest_start + param_numels[largest_idx]
+ latent_dim = math.ceil(sum(param_numels) * 0.5)
+
+ geom1 = V6GeometryConfig(config_id="g1", projection_seed=100, latent_dim=latent_dim)
+ geom2 = V6GeometryConfig(config_id="g2", projection_seed=100, latent_dim=latent_dim)
+ geom3 = V6GeometryConfig(config_id="g3", projection_seed=999, latent_dim=latent_dim)
+
+ device = torch.device("cpu")
+ t1 = LargestTensorHashLatentTransform(model, geom1, device)
+ t2 = LargestTensorHashLatentTransform(model, geom2, device)
+ t3 = LargestTensorHashLatentTransform(model, geom3, device)
+
+ # Identical seed produces identical transform
+ assert torch.equal(t1.k_indices, t2.k_indices)
+ assert torch.equal(t1.weights, t2.weights)
+
+ # Changed seed keeps direct/non-largest parameters identical
+ direct_mask = torch.ones(sum(param_numels), dtype=torch.bool)
+ direct_mask[largest_start:largest_end] = False
+ assert torch.equal(t1.k_indices[direct_mask], t3.k_indices[direct_mask])
+ assert torch.equal(t1.weights[direct_mask], t3.weights[direct_mask])
+
+ # Changed seed varies hashed mapping/signs for the largest tensor
+ largest_slice = slice(largest_start, largest_end)
+ assert (
+ not torch.equal(t1.k_indices[largest_slice], t3.k_indices[largest_slice])
+ or not torch.equal(t1.weights[largest_slice], t3.weights[largest_slice])
+ )
+
+
+def test_largest_tensor_hash_transform_decode_formula():
+ """Verify LargestTensorHashLatentTransform decode matches the mapped formula."""
+ model = nn.Sequential(nn.Linear(20, 10), nn.Linear(10, 2))
+ total_dim = sum(p.numel() for p in model.parameters())
+ latent_dim = math.ceil(total_dim * 0.5)
+ geom_cfg = V6GeometryConfig(config_id="g_decode", projection_seed=42, latent_dim=latent_dim)
+ device = torch.device("cpu")
+ transform = LargestTensorHashLatentTransform(model, geom_cfg, device)
+
+ Z = torch.randn(4, latent_dim)
+ delta = Z[:, transform.k_indices] * transform.weights
+ expected = transform.base_vec + transform.scale_vec * delta
+ actual = transform.decode(Z)
+ assert torch.allclose(actual, expected)
+
+
+def test_largest_tensor_hash_transform_invalid_latent_budgets():
+ """Verify LargestTensorHashLatentTransform rejects configurations where latent_dim cannot provide >= 1 coordinate for largest tensor."""
+ model = nn.Sequential(nn.Linear(20, 10), nn.Linear(10, 2))
+ param_numels = [p.numel() for p in model.parameters()]
+ largest_idx = int(np.argmax(param_numels))
+ protected_dim = sum(numel for i, numel in enumerate(param_numels) if i != largest_idx)
+
+ # latent_dim <= protected_dim should fail
+ geom_invalid = V6GeometryConfig(config_id="g_inv", projection_seed=42, latent_dim=protected_dim)
+ device = torch.device("cpu")
+ with pytest.raises(ValueError, match="latent_dim .* must be greater than protected"):
+ LargestTensorHashLatentTransform(model, geom_invalid, device)
+
+
+def test_largest_tensor_hash_full_dimensional_parity():
+ """Verify LargestTensorHashLatentTransform preserves full-dimensional parity when latent_dim == total_dim."""
+ model = nn.Sequential(nn.Linear(10, 5))
+ total_dim = sum(p.numel() for p in model.parameters())
+ geom_cfg = V6GeometryConfig(config_id="g_full", projection_seed=42, latent_dim=total_dim)
+ device = torch.device("cpu")
+
+ transform_lth = LargestTensorHashLatentTransform(model, geom_cfg, device)
+ transform_v6 = V6LatentTransform(model, geom_cfg, device)
+
+ assert transform_lth.is_full is True
+ Z = torch.randn(3, total_dim)
+ assert torch.allclose(transform_lth.decode(Z), transform_v6.decode(Z))
+
+
+def test_largest_tensor_hash_unchanged_core_state_bytes():
+ """Verify state bytes accounting is identical for largest_tensor_hash, global, and other scopes."""
+ bytes_global = compute_core_swarm_state_bytes(12, 4549)
+ bytes_lth = compute_core_swarm_state_bytes(12, 4549)
+ assert bytes_global == bytes_lth == 5 * 12 * 4549 * 4
+
+
+def test_largest_tensor_hash_runner_provenance_and_persistence(monkeypatch, tmp_path: Path):
+ """Verify mixed projection_scope {global, largest_tensor_hash, global, largest_tensor_hash} is accepted and persists at all levels."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ mixed_scope = {
+ "mnist_compact": "global",
+ "mnist_wide": "largest_tensor_hash",
+ "fashion_compact": "global",
+ "fashion_wide": "largest_tensor_hash",
+ }
+
+ payload = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ geometry_policy="baseline_aligned",
+ projection_scope=mixed_scope,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert payload["experiment_config"]["projection_scope"] == mixed_scope
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "global"
+ assert payload["workloads"]["mnist_wide"]["projection_scope"] == "largest_tensor_hash"
+
+ cand_runs = payload["candidate_runs"]["mixed_aligned_r0.5"]
+ assert cand_runs["mnist_compact"]["projection_scope"] == "global"
+ assert cand_runs["mnist_wide"]["projection_scope"] == "largest_tensor_hash"
+ assert cand_runs["mnist_compact"]["per_seed_runs"][0]["projection_scope"] == "global"
+ assert cand_runs["mnist_wide"]["per_seed_runs"][0]["projection_scope"] == "largest_tensor_hash"
+def test_largest_tensor_row_hash_transform_mapping_allocation_and_containment():
+ """Verify LargestTensorRowHashLatentTransform maps non-largest tensors direct, partitions residual range across rows without overlap, and allocates exact sum."""
+ from heavy_task_feasibility import create_model
+ model = create_model("wide_cnn")
+ param_numels = [p.numel() for p in model.parameters()]
+ param_shapes = [p.shape for p in model.parameters()]
+ total_dim = sum(param_numels)
+ largest_idx = int(np.argmax(param_numels))
+ protected_dim = sum(numel for i, numel in enumerate(param_numels) if i != largest_idx)
+
+ latent_dim = math.ceil(total_dim * 0.5)
+ geom_cfg = V6GeometryConfig(
+ config_id="test_ltrh_containment",
+ projection_seed=12345,
+ latent_dim=latent_dim,
+ )
+ device = torch.device("cpu")
+ transform = LargestTensorRowHashLatentTransform(model, geom_cfg, device)
+
+ residual_dim = latent_dim - protected_dim
+ assert protected_dim == 5162
+ assert residual_dim == 22507
+
+ shape = param_shapes[largest_idx]
+ num_rows = shape[0] if len(shape) >= 2 else 1
+ assert num_rows == 32
+ assert len(transform.row_latent_dims) == 32
+ assert sum(transform.row_latent_dims) == residual_dim
+
+ k_indices = transform.k_indices.cpu().numpy()
+ weights = transform.weights.cpu().numpy()
+
+ # 1. Protected direct mapping
+ j_offset = 0
+ direct_coord = 0
+ for i, numel in enumerate(param_numels):
+ if i != largest_idx:
+ j_slice = slice(j_offset, j_offset + numel)
+ expected_coords = np.arange(direct_coord, direct_coord + numel)
+ assert np.array_equal(k_indices[j_slice], expected_coords)
+ assert np.array_equal(weights[j_slice], np.ones(numel, dtype=np.float32))
+ direct_coord += numel
+ j_offset += numel
+ else:
+ j_largest_start = j_offset
+ j_offset += numel
+
+ # 2. Row slices non-overlap and containment
+ elements_per_row = param_numels[largest_idx] // num_rows
+ row_start_coord = protected_dim
+ for r in range(num_rows):
+ r_dim = transform.row_latent_dims[r]
+ assert r_dim >= 1
+ r_end_coord = row_start_coord + r_dim
+ r_j_slice = slice(
+ j_largest_start + r * elements_per_row,
+ j_largest_start + (r + 1) * elements_per_row,
+ )
+ r_k = k_indices[r_j_slice]
+ assert np.all(r_k >= row_start_coord)
+ assert np.all(r_k < r_end_coord)
+ row_start_coord = r_end_coord
+
+ assert row_start_coord == latent_dim
+
+
+def test_largest_tensor_row_hash_transform_determinism_and_seed_variation():
+ """Verify LargestTensorRowHashLatentTransform reproduces for same seed and varies only hashed mapping/signs for changed seed."""
+ from heavy_task_feasibility import create_model
+ model = create_model("wide_cnn")
+ param_numels = [p.numel() for p in model.parameters()]
+ largest_idx = int(np.argmax(param_numels))
+ largest_start = sum(param_numels[:largest_idx])
+ largest_end = largest_start + param_numels[largest_idx]
+ latent_dim = math.ceil(sum(param_numels) * 0.5)
+
+ geom1 = V6GeometryConfig(config_id="g1", projection_seed=100, latent_dim=latent_dim)
+ geom2 = V6GeometryConfig(config_id="g2", projection_seed=100, latent_dim=latent_dim)
+ geom3 = V6GeometryConfig(config_id="g3", projection_seed=999, latent_dim=latent_dim)
+
+ device = torch.device("cpu")
+ t1 = LargestTensorRowHashLatentTransform(model, geom1, device)
+ t2 = LargestTensorRowHashLatentTransform(model, geom2, device)
+ t3 = LargestTensorRowHashLatentTransform(model, geom3, device)
+
+ # Identical seed produces identical transform
+ assert torch.equal(t1.k_indices, t2.k_indices)
+ assert torch.equal(t1.weights, t2.weights)
+
+ # Changed seed keeps direct/non-largest parameters identical
+ direct_mask = torch.ones(sum(param_numels), dtype=torch.bool)
+ direct_mask[largest_start:largest_end] = False
+ assert torch.equal(t1.k_indices[direct_mask], t3.k_indices[direct_mask])
+ assert torch.equal(t1.weights[direct_mask], t3.weights[direct_mask])
+
+ # Changed seed varies hashed mapping/signs for the largest tensor
+ largest_slice = slice(largest_start, largest_end)
+ assert (
+ not torch.equal(t1.k_indices[largest_slice], t3.k_indices[largest_slice])
+ or not torch.equal(t1.weights[largest_slice], t3.weights[largest_slice])
+ )
+
+
+def test_largest_tensor_row_hash_transform_decode_formula():
+ """Verify LargestTensorRowHashLatentTransform decode matches the mapped formula."""
+ model = nn.Sequential(nn.Linear(20, 10), nn.Linear(10, 2))
+ total_dim = sum(p.numel() for p in model.parameters())
+ latent_dim = math.ceil(total_dim * 0.5)
+ geom_cfg = V6GeometryConfig(config_id="g_decode_row", projection_seed=42, latent_dim=latent_dim)
+ device = torch.device("cpu")
+ transform = LargestTensorRowHashLatentTransform(model, geom_cfg, device)
+
+ Z = torch.randn(4, latent_dim)
+ delta = Z[:, transform.k_indices] * transform.weights
+ expected = transform.base_vec + transform.scale_vec * delta
+ actual = transform.decode(Z)
+ assert torch.allclose(actual, expected)
+
+
+def test_largest_tensor_row_hash_transform_invalid_latent_budgets():
+ """Verify LargestTensorRowHashLatentTransform rejects configurations where residual_dim < num_rows."""
+ model = nn.Sequential(nn.Linear(20, 10), nn.Linear(10, 2))
+ param_numels = [p.numel() for p in model.parameters()]
+ largest_idx = int(np.argmax(param_numels))
+ protected_dim = sum(numel for i, numel in enumerate(param_numels) if i != largest_idx)
+
+ num_rows = list(model.parameters())[largest_idx].shape[0]
+ # One fewer than the minimum residual coordinate count must fail.
+ geom_invalid = V6GeometryConfig(
+ config_id="g_inv_row",
+ projection_seed=42,
+ latent_dim=protected_dim + num_rows - 1,
+ )
+ device = torch.device("cpu")
+ with pytest.raises(ValueError, match="latent_dim .* must be at least protected dimension"):
+ LargestTensorRowHashLatentTransform(model, geom_invalid, device)
+
+
+def test_largest_tensor_row_hash_full_dimensional_parity():
+ """Verify LargestTensorRowHashLatentTransform preserves full-dimensional parity when latent_dim == total_dim."""
+ model = nn.Sequential(nn.Linear(10, 5))
+ total_dim = sum(p.numel() for p in model.parameters())
+ geom_cfg = V6GeometryConfig(config_id="g_full_row", projection_seed=42, latent_dim=total_dim)
+ device = torch.device("cpu")
+
+ transform_ltrh = LargestTensorRowHashLatentTransform(model, geom_cfg, device)
+ transform_v6 = V6LatentTransform(model, geom_cfg, device)
+
+ assert transform_ltrh.is_full is True
+ Z = torch.randn(3, total_dim)
+ assert torch.allclose(transform_ltrh.decode(Z), transform_v6.decode(Z))
+
+
+def test_largest_tensor_row_hash_unchanged_core_state_bytes():
+ """Verify state bytes accounting is identical for largest_tensor_row_hash, global, and other scopes."""
+ bytes_global = compute_core_swarm_state_bytes(12, 4549)
+ bytes_ltrh = compute_core_swarm_state_bytes(12, 4549)
+ assert bytes_global == bytes_ltrh == 5 * 12 * 4549 * 4
+
+
+def test_largest_tensor_row_hash_runner_provenance_and_persistence(monkeypatch, tmp_path: Path):
+ """Verify mixed projection_scope {global, largest_tensor_row_hash, global, largest_tensor_row_hash} is accepted and persists at all levels."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ mixed_scope = {
+ "mnist_compact": "global",
+ "mnist_wide": "largest_tensor_row_hash",
+ "fashion_compact": "global",
+ "fashion_wide": "largest_tensor_row_hash",
+ }
+
+ payload = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ geometry_policy="baseline_aligned",
+ projection_scope=mixed_scope,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert payload["experiment_config"]["projection_scope"] == mixed_scope
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "global"
+ assert payload["workloads"]["mnist_wide"]["projection_scope"] == "largest_tensor_row_hash"
+
+ cand_runs = payload["candidate_runs"]["mixed_aligned_r0.5"]
+ assert cand_runs["mnist_compact"]["projection_scope"] == "global"
+ assert cand_runs["mnist_wide"]["projection_scope"] == "largest_tensor_row_hash"
+ assert cand_runs["mnist_compact"]["per_seed_runs"][0]["projection_scope"] == "global"
+ assert cand_runs["mnist_wide"]["per_seed_runs"][0]["projection_scope"] == "largest_tensor_row_hash"
+def test_adjacent_pair_transform_mapping_allocation_and_containment():
+ """Verify AdjacentPairLatentTransform pairs parameters tensor-locally, allocates sum(ceil(numel/2)), and prevents cross-tensor coordinate sharing."""
+ model = nn.Sequential(nn.Linear(5, 4), nn.Linear(4, 3))
+ # param_numels: [20, 4, 12, 3] -> ceil(numel/2): [10, 2, 6, 2], total required_dim = 20
+ total_dim = sum(p.numel() for p in model.parameters())
+ geom_cfg = V6GeometryConfig(config_id="g_adj", projection_seed=42, latent_dim=20)
+ device = torch.device("cpu")
+
+ transform = AdjacentPairLatentTransform(model, geom_cfg, device)
+ assert transform.latent_dim == 20
+ assert transform.tensor_latent_dims == [10, 2, 6, 2]
+
+ # Verify tensor bounds and coordinate containment
+ k_indices = transform.k_indices.cpu().numpy()
+ j_offsets = [0, 20, 24, 36, 39]
+ l_offsets = [0, 10, 12, 18, 20]
+
+ for i in range(4):
+ tensor_k = k_indices[j_offsets[i]:j_offsets[i+1]]
+ assert np.all(tensor_k >= l_offsets[i])
+ assert np.all(tensor_k < l_offsets[i+1])
+
+
+def test_adjacent_pair_transform_pairing_and_normalized_weights():
+ """Verify AdjacentPairLatentTransform maps consecutive pairs to same latent coordinate with weight 1/sqrt(2), unpaired final parameter to 1.0, and column norm == 1.0."""
+ class OddEvenModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.p1 = nn.Parameter(torch.randn(5)) # odd -> 3 latent coords
+ self.p2 = nn.Parameter(torch.randn(4)) # even -> 2 latent coords
+
+ model = OddEvenModel()
+ # param_numels: [5, 4] -> ceil(numel/2): [3, 2], required_dim = 5
+ geom_cfg = V6GeometryConfig(config_id="g_adj", projection_seed=42, latent_dim=5)
+ device = torch.device("cpu")
+
+ transform = AdjacentPairLatentTransform(model, geom_cfg, device)
+ k_indices = transform.k_indices.cpu().numpy()
+ weights = transform.weights.cpu().numpy()
+ inv_sqrt2 = 1.0 / math.sqrt(2.0)
+
+ # Tensor 0 (size 5):
+ # p=0,1 -> k=0, w=inv_sqrt2
+ # p=2,3 -> k=1, w=inv_sqrt2
+ # p=4 -> k=2, w=1.0
+ assert k_indices[0] == k_indices[1] == 0
+ assert k_indices[2] == k_indices[3] == 1
+ assert k_indices[4] == 2
+
+ assert np.isclose(weights[0], inv_sqrt2)
+ assert np.isclose(weights[1], inv_sqrt2)
+ assert np.isclose(weights[2], inv_sqrt2)
+ assert np.isclose(weights[3], inv_sqrt2)
+ assert np.isclose(weights[4], 1.0)
+
+ # Tensor 1 (size 4):
+ # p=5,6 -> k=3, w=inv_sqrt2
+ # p=7,8 -> k=4, w=inv_sqrt2
+ assert k_indices[5] == k_indices[6] == 3
+ assert k_indices[7] == k_indices[8] == 4
+ assert np.isclose(weights[5], inv_sqrt2)
+ assert np.isclose(weights[6], inv_sqrt2)
+ assert np.isclose(weights[7], inv_sqrt2)
+ assert np.isclose(weights[8], inv_sqrt2)
+
+ # Verify column norm = 1.0 for every latent coordinate
+ for k in range(5):
+ j_col = np.where(k_indices == k)[0]
+ col_norm = math.sqrt(sum(weights[j]**2 for j in j_col))
+ assert np.isclose(col_norm, 1.0)
+
+
+def test_adjacent_pair_transform_seed_independence():
+ """Verify AdjacentPairLatentTransform mapping and weights are completely deterministic and seed-independent."""
+ model = nn.Sequential(nn.Linear(10, 5), nn.Linear(5, 2))
+ req_dim = sum(math.ceil(p.numel() / 2) for p in model.parameters())
+ device = torch.device("cpu")
+
+ geom_cfg1 = V6GeometryConfig(config_id="g1", projection_seed=101, latent_dim=req_dim)
+ geom_cfg2 = V6GeometryConfig(config_id="g2", projection_seed=999999, latent_dim=req_dim)
+ geom_cfg3 = V6GeometryConfig(config_id="g3", projection_seed=None, latent_dim=req_dim)
+
+ t1 = AdjacentPairLatentTransform(model, geom_cfg1, device)
+ t2 = AdjacentPairLatentTransform(model, geom_cfg2, device)
+ t3 = AdjacentPairLatentTransform(model, geom_cfg3, device)
+
+ assert torch.equal(t1.k_indices, t2.k_indices)
+ assert torch.equal(t1.k_indices, t3.k_indices)
+ assert torch.allclose(t1.weights, t2.weights)
+ assert torch.allclose(t1.weights, t3.weights)
+
+
+def test_adjacent_pair_transform_decode_formula():
+ """Verify AdjacentPairLatentTransform decode matches base_vec + scale_vec * (Z[:, k_indices] * weights)."""
+ model = nn.Sequential(nn.Linear(6, 4), nn.Linear(4, 2))
+ req_dim = sum(math.ceil(p.numel() / 2) for p in model.parameters())
+ geom_cfg = V6GeometryConfig(config_id="g_adj", projection_seed=42, latent_dim=req_dim)
+ device = torch.device("cpu")
+
+ transform = AdjacentPairLatentTransform(model, geom_cfg, device)
+ Z = torch.randn(5, req_dim)
+ decoded = transform.decode(Z)
+
+ expected_delta = Z[:, transform.k_indices] * transform.weights
+ expected_theta = transform.base_vec + transform.scale_vec * expected_delta
+
+ assert torch.allclose(decoded, expected_theta)
+
+
+def test_adjacent_pair_transform_required_dimension_rejection():
+ """Verify AdjacentPairLatentTransform rejects non-full configurations where latent_dim != sum(ceil(numel/2))."""
+ model = nn.Sequential(nn.Linear(10, 5), nn.Linear(5, 2))
+ req_dim = sum(math.ceil(p.numel() / 2) for p in model.parameters())
+ device = torch.device("cpu")
+
+ invalid_latent_dim = req_dim - 1
+ geom_invalid = V6GeometryConfig(config_id="g_inv", projection_seed=42, latent_dim=invalid_latent_dim)
+
+ with pytest.raises(ValueError, match="AdjacentPairLatentTransform requires latent_dim == sum\\(ceil\\(numel_i/2\\)\\)"):
+ AdjacentPairLatentTransform(model, geom_invalid, device)
+
+
+def test_adjacent_pair_full_dimensional_parity():
+ """Verify AdjacentPairLatentTransform preserves full-dimensional parity when latent_dim == total_dim."""
+ model = nn.Sequential(nn.Linear(10, 5))
+ total_dim = sum(p.numel() for p in model.parameters())
+ geom_cfg = V6GeometryConfig(config_id="g_full_adj", projection_seed=42, latent_dim=total_dim)
+ device = torch.device("cpu")
+
+ transform_adj = AdjacentPairLatentTransform(model, geom_cfg, device)
+ transform_v6 = V6LatentTransform(model, geom_cfg, device)
+
+ assert transform_adj.is_full is True
+ assert transform_adj.tensor_latent_dims == [p.numel() for p in model.parameters()]
+ Z = torch.randn(3, total_dim)
+ assert torch.allclose(transform_adj.decode(Z), transform_v6.decode(Z))
+
+
+def test_adjacent_pair_unchanged_core_state_bytes():
+ """Verify state bytes accounting is identical for adjacent_pair, global, and other scopes."""
+ bytes_global = compute_core_swarm_state_bytes(12, 4549)
+ bytes_adj = compute_core_swarm_state_bytes(12, 4549)
+ assert bytes_global == bytes_adj == 5 * 12 * 4549 * 4
+
+
+def test_adjacent_pair_mixed_wide_only_runner_provenance_and_persistence(monkeypatch, tmp_path: Path):
+ """Verify mixed projection_scope {global, adjacent_pair, global, adjacent_pair} is accepted and persists at all levels."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ mixed_scope = {
+ "mnist_compact": "global",
+ "mnist_wide": "adjacent_pair",
+ "fashion_compact": "global",
+ "fashion_wide": "adjacent_pair",
+ }
+
+ payload = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ geometry_policy="baseline_aligned",
+ projection_scope=mixed_scope,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert payload["experiment_config"]["projection_scope"] == mixed_scope
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "global"
+ assert payload["workloads"]["mnist_wide"]["projection_scope"] == "adjacent_pair"
+
+ cand_runs = payload["candidate_runs"]["mixed_aligned_r0.5"]
+ assert cand_runs["mnist_compact"]["projection_scope"] == "global"
+ assert cand_runs["mnist_wide"]["projection_scope"] == "adjacent_pair"
+ assert cand_runs["mnist_compact"]["per_seed_runs"][0]["projection_scope"] == "global"
+ assert cand_runs["mnist_wide"]["per_seed_runs"][0]["projection_scope"] == "adjacent_pair"
+
+
+def test_adjacent_pair_compact_and_wide_acceptance_criteria():
+ """Verify that for both CompactCNN and WideCNN architectures at ratio 0.5, AdjacentPairLatentTransform covers every tensor, has column norm 1 for every latent column, and matches half-dim."""
+ from heavy_task_feasibility import create_model
+
+ for wl_name in ["compact_cnn", "wide_cnn"]:
+ model = create_model(wl_name)
+ total_dim = sum(p.numel() for p in model.parameters())
+ runner_half_dim = compute_latent_dim(total_dim, 0.5)
+
+ req_dim = sum(math.ceil(p.numel() / 2) for p in model.parameters())
+ assert req_dim == runner_half_dim, f"For model {wl_name}, required pair dim {req_dim} must equal runner half-dim {runner_half_dim}"
+
+ geom_cfg = V6GeometryConfig(config_id=f"g_{wl_name}", projection_seed=42, latent_dim=runner_half_dim)
+ device = torch.device("cpu")
+
+ transform = AdjacentPairLatentTransform(model, geom_cfg, device)
+ assert transform.latent_dim == runner_half_dim
+
+ # Check total parameter coverage
+ assert len(transform.k_indices) == total_dim
+ assert len(transform.weights) == total_dim
+
+ k_indices = transform.k_indices.cpu().numpy()
+ weights = transform.weights.cpu().numpy()
+
+ j_offset = 0
+ for p in model.parameters():
+ numel = p.numel()
+ tensor_k = k_indices[j_offset:j_offset + numel]
+ # Check tensor-local contiguous latent coords
+ assert np.min(tensor_k) >= 0
+ assert np.max(tensor_k) < runner_half_dim
+ j_offset += numel
+
+ # Check column norm = 1.0 for all latent columns
+ for k in range(runner_half_dim):
+ j_col = np.where(k_indices == k)[0]
+ assert 1 <= len(j_col) <= 2, f"Latent column {k} must map to 1 or 2 parameters, got {len(j_col)}"
+ if len(j_col) == 2:
+ # Non-singleton: adjacent parameters from one tensor
+ assert j_col[1] == j_col[0] + 1
+ col_norm = math.sqrt(sum(weights[j]**2 for j in j_col))
+ assert np.isclose(col_norm, 1.0), f"Latent column {k} column norm must be 1.0, got {col_norm}"
+def test_adjacent_difference_transform_mapping_allocation_and_containment():
+ """Verify AdjacentDifferenceLatentTransform pairs parameters tensor-locally, allocates sum(ceil(numel/2)), and prevents cross-tensor coordinate sharing."""
+ model = nn.Sequential(nn.Linear(5, 4), nn.Linear(4, 3))
+ # param_numels: [20, 4, 12, 3] -> ceil(numel/2): [10, 2, 6, 2], total required_dim = 20
+ total_dim = sum(p.numel() for p in model.parameters())
+ geom_cfg = V6GeometryConfig(config_id="g_adj_diff", projection_seed=42, latent_dim=20)
+ device = torch.device("cpu")
+
+ transform = AdjacentDifferenceLatentTransform(model, geom_cfg, device)
+ assert transform.latent_dim == 20
+ assert transform.tensor_latent_dims == [10, 2, 6, 2]
+
+ # Verify tensor bounds and coordinate containment
+ k_indices = transform.k_indices.cpu().numpy()
+ j_offsets = [0, 20, 24, 36, 39]
+ l_offsets = [0, 10, 12, 18, 20]
+
+ for i in range(4):
+ tensor_k = k_indices[j_offsets[i]:j_offsets[i+1]]
+ assert np.all(tensor_k >= l_offsets[i])
+ assert np.all(tensor_k < l_offsets[i+1])
+
+
+def test_adjacent_difference_transform_pairing_and_normalized_weights():
+ """Verify AdjacentDifferenceLatentTransform maps consecutive pairs to same latent coordinate with opposite weights (+1/sqrt(2), -1/sqrt(2)), zero pair-column sums, unpaired final parameter to 1.0, and column norm == 1.0."""
+ class OddEvenModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.p1 = nn.Parameter(torch.randn(5)) # odd -> 3 latent coords
+ self.p2 = nn.Parameter(torch.randn(4)) # even -> 2 latent coords
+
+ model = OddEvenModel()
+ # param_numels: [5, 4] -> ceil(numel/2): [3, 2], required_dim = 5
+ geom_cfg = V6GeometryConfig(config_id="g_adj_diff", projection_seed=42, latent_dim=5)
+ device = torch.device("cpu")
+
+ transform = AdjacentDifferenceLatentTransform(model, geom_cfg, device)
+ k_indices = transform.k_indices.cpu().numpy()
+ weights = transform.weights.cpu().numpy()
+ inv_sqrt2 = 1.0 / math.sqrt(2.0)
+
+ # Tensor 0 (size 5):
+ # p=0,1 -> k=0, w=(+inv_sqrt2, -inv_sqrt2)
+ # p=2,3 -> k=1, w=(+inv_sqrt2, -inv_sqrt2)
+ # p=4 -> k=2, w=+1.0
+ assert k_indices[0] == k_indices[1] == 0
+ assert k_indices[2] == k_indices[3] == 1
+ assert k_indices[4] == 2
+
+ assert np.isclose(weights[0], +inv_sqrt2)
+ assert np.isclose(weights[1], -inv_sqrt2)
+ assert np.isclose(weights[2], +inv_sqrt2)
+ assert np.isclose(weights[3], -inv_sqrt2)
+ assert np.isclose(weights[4], 1.0)
+
+ # Tensor 1 (size 4):
+ # p=5,6 -> k=3, w=(+inv_sqrt2, -inv_sqrt2)
+ # p=7,8 -> k=4, w=(+inv_sqrt2, -inv_sqrt2)
+ assert k_indices[5] == k_indices[6] == 3
+ assert k_indices[7] == k_indices[8] == 4
+ assert np.isclose(weights[5], +inv_sqrt2)
+ assert np.isclose(weights[6], -inv_sqrt2)
+ assert np.isclose(weights[7], +inv_sqrt2)
+ assert np.isclose(weights[8], -inv_sqrt2)
+
+ # Verify zero pair-column sums and column norm = 1.0 for every latent coordinate
+ for k in range(5):
+ j_col = np.where(k_indices == k)[0]
+ if len(j_col) == 2:
+ col_sum = sum(weights[j] for j in j_col)
+ assert np.isclose(col_sum, 0.0), f"Pair column {k} sum must be 0.0, got {col_sum}"
+ elif len(j_col) == 1:
+ assert np.isclose(weights[j_col[0]], 1.0)
+ col_norm = math.sqrt(sum(weights[j]**2 for j in j_col))
+ assert np.isclose(col_norm, 1.0), f"Column {k} norm must be 1.0, got {col_norm}"
+
+
+def test_adjacent_difference_transform_seed_independence():
+ """Verify AdjacentDifferenceLatentTransform mapping and weights are completely deterministic and seed-independent."""
+ model = nn.Sequential(nn.Linear(10, 5), nn.Linear(5, 2))
+ req_dim = sum(math.ceil(p.numel() / 2) for p in model.parameters())
+ device = torch.device("cpu")
+
+ geom_cfg1 = V6GeometryConfig(config_id="g1", projection_seed=101, latent_dim=req_dim)
+ geom_cfg2 = V6GeometryConfig(config_id="g2", projection_seed=999999, latent_dim=req_dim)
+ geom_cfg3 = V6GeometryConfig(config_id="g3", projection_seed=None, latent_dim=req_dim)
+
+ t1 = AdjacentDifferenceLatentTransform(model, geom_cfg1, device)
+ t2 = AdjacentDifferenceLatentTransform(model, geom_cfg2, device)
+ t3 = AdjacentDifferenceLatentTransform(model, geom_cfg3, device)
+
+ assert torch.equal(t1.k_indices, t2.k_indices)
+ assert torch.equal(t1.k_indices, t3.k_indices)
+ assert torch.allclose(t1.weights, t2.weights)
+ assert torch.allclose(t1.weights, t3.weights)
+
+
+def test_adjacent_difference_transform_decode_formula():
+ """Verify AdjacentDifferenceLatentTransform decode matches base_vec + scale_vec * (Z[:, k_indices] * weights)."""
+ model = nn.Sequential(nn.Linear(6, 4), nn.Linear(4, 2))
+ req_dim = sum(math.ceil(p.numel() / 2) for p in model.parameters())
+ geom_cfg = V6GeometryConfig(config_id="g_adj_diff", projection_seed=42, latent_dim=req_dim)
+ device = torch.device("cpu")
+
+ transform = AdjacentDifferenceLatentTransform(model, geom_cfg, device)
+ Z = torch.randn(5, req_dim)
+ decoded = transform.decode(Z)
+
+ expected_delta = Z[:, transform.k_indices] * transform.weights
+ expected_theta = transform.base_vec + transform.scale_vec * expected_delta
+
+ assert torch.allclose(decoded, expected_theta)
+
+
+def test_adjacent_difference_transform_required_dimension_rejection():
+ """Verify AdjacentDifferenceLatentTransform rejects non-full configurations where latent_dim != sum(ceil(numel/2))."""
+ model = nn.Sequential(nn.Linear(10, 5), nn.Linear(5, 2))
+ req_dim = sum(math.ceil(p.numel() / 2) for p in model.parameters())
+ device = torch.device("cpu")
+
+ invalid_latent_dim = req_dim - 1
+ geom_invalid = V6GeometryConfig(config_id="g_inv", projection_seed=42, latent_dim=invalid_latent_dim)
+
+ with pytest.raises(ValueError, match="AdjacentDifferenceLatentTransform requires latent_dim == sum\\(ceil\\(numel_i/2\\)\\)"):
+ AdjacentDifferenceLatentTransform(model, geom_invalid, device)
+
+
+def test_adjacent_difference_full_dimensional_parity():
+ """Verify AdjacentDifferenceLatentTransform preserves full-dimensional parity when latent_dim == total_dim."""
+ model = nn.Sequential(nn.Linear(10, 5))
+ total_dim = sum(p.numel() for p in model.parameters())
+ geom_cfg = V6GeometryConfig(config_id="g_full_adj_diff", projection_seed=42, latent_dim=total_dim)
+ device = torch.device("cpu")
+
+ transform_adj = AdjacentDifferenceLatentTransform(model, geom_cfg, device)
+ transform_v6 = V6LatentTransform(model, geom_cfg, device)
+
+ assert transform_adj.is_full is True
+ assert transform_adj.tensor_latent_dims == [p.numel() for p in model.parameters()]
+ Z = torch.randn(3, total_dim)
+ assert torch.allclose(transform_adj.decode(Z), transform_v6.decode(Z))
+
+
+def test_adjacent_difference_unchanged_core_state_bytes():
+ """Verify state bytes accounting is identical for adjacent_difference, adjacent_pair, global, and other scopes."""
+ bytes_global = compute_core_swarm_state_bytes(12, 4549)
+ bytes_adj_diff = compute_core_swarm_state_bytes(12, 4549)
+ assert bytes_global == bytes_adj_diff == 5 * 12 * 4549 * 4
+
+
+def test_adjacent_difference_mixed_wide_only_runner_provenance_and_persistence(monkeypatch, tmp_path: Path):
+ """Verify mixed projection_scope {global, adjacent_difference, global, adjacent_difference} is accepted and persists at all levels."""
+ monkeypatch.setattr(heavy_pso_autoresearch, "prepare_heavy_task_data", _mock_prepare_heavy_task_data)
+
+ mixed_scope = {
+ "mnist_compact": "global",
+ "mnist_wide": "adjacent_difference",
+ "fashion_compact": "global",
+ "fashion_wide": "adjacent_difference",
+ }
+
+ payload = run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ subset_size=10,
+ seeds=[101],
+ geometry_policy="baseline_aligned",
+ projection_scope=mixed_scope,
+ device_str="cpu",
+ cache_dir=tmp_path,
+ )
+
+ assert payload["experiment_config"]["projection_scope"] == mixed_scope
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "global"
+ assert payload["workloads"]["mnist_wide"]["projection_scope"] == "adjacent_difference"
+
+ cand_runs = payload["candidate_runs"]["mixed_aligned_r0.5"]
+ assert cand_runs["mnist_compact"]["projection_scope"] == "global"
+ assert cand_runs["mnist_wide"]["projection_scope"] == "adjacent_difference"
+ assert cand_runs["mnist_compact"]["per_seed_runs"][0]["projection_scope"] == "global"
+ assert cand_runs["mnist_wide"]["per_seed_runs"][0]["projection_scope"] == "adjacent_difference"
+
+
+def test_adjacent_difference_compact_and_wide_acceptance_criteria():
+ """Verify that for both CompactCNN and WideCNN architectures at ratio 0.5, AdjacentDifferenceLatentTransform covers every tensor, has column norm 1 for every latent column, zero pair-column sums, and matches half-dim."""
+ from heavy_task_feasibility import create_model
+
+ for wl_name in ["compact_cnn", "wide_cnn"]:
+ model = create_model(wl_name)
+ total_dim = sum(p.numel() for p in model.parameters())
+ runner_half_dim = compute_latent_dim(total_dim, 0.5)
+
+ req_dim = sum(math.ceil(p.numel() / 2) for p in model.parameters())
+ assert req_dim == runner_half_dim, f"For model {wl_name}, required pair dim {req_dim} must equal runner half-dim {runner_half_dim}"
+
+ geom_cfg = V6GeometryConfig(config_id=f"g_{wl_name}", projection_seed=42, latent_dim=runner_half_dim)
+ device = torch.device("cpu")
+
+ transform = AdjacentDifferenceLatentTransform(model, geom_cfg, device)
+ assert transform.latent_dim == runner_half_dim
+
+ # Check total parameter coverage
+ assert len(transform.k_indices) == total_dim
+ assert len(transform.weights) == total_dim
+
+ k_indices = transform.k_indices.cpu().numpy()
+ weights = transform.weights.cpu().numpy()
+
+ j_offset = 0
+ for p in model.parameters():
+ numel = p.numel()
+ tensor_k = k_indices[j_offset:j_offset + numel]
+ # Check tensor-local contiguous latent coords
+ assert np.min(tensor_k) >= 0
+ assert np.max(tensor_k) < runner_half_dim
+ j_offset += numel
+
+ # Check column norm = 1.0 and pair column sums = 0.0 for all latent columns
+ for k in range(runner_half_dim):
+ j_col = np.where(k_indices == k)[0]
+ assert 1 <= len(j_col) <= 2, f"Latent column {k} must map to 1 or 2 parameters, got {len(j_col)}"
+ if len(j_col) == 2:
+ # Non-singleton: adjacent parameters from one tensor with opposite weights
+ assert j_col[1] == j_col[0] + 1
+ pair_sum = weights[j_col[0]] + weights[j_col[1]]
+ assert np.isclose(pair_sum, 0.0), f"Latent pair column {k} sum must be 0.0, got {pair_sum}"
+ else:
+ assert np.isclose(weights[j_col[0]], 1.0)
+ col_norm = math.sqrt(sum(weights[j]**2 for j in j_col))
+ assert np.isclose(col_norm, 1.0), f"Latent column {k} column norm must be 1.0, got {col_norm}"
diff --git a/tests/test_heavy_pso_cross_split.py b/tests/test_heavy_pso_cross_split.py
new file mode 100644
index 0000000..5c1308d
--- /dev/null
+++ b/tests/test_heavy_pso_cross_split.py
@@ -0,0 +1,670 @@
+"""
+Unit tests for Heavy PSO Cross-Split Runner and Evaluator.
+
+Covers:
+1. Split seed propagation through data preparation, confirm runner, and autoresearch.
+2. Per-workload projection seed override validation, parsing, and effective seeds.
+3. Artifact accounting (exact queries/samples), fingerprint matching, state math, and test seals.
+4. Cross-split runner phase seed enforcement (development vs confirmation).
+5. All evaluator hard gates, missing confirmation rejection, non-finite rejection, leakage control,
+ per-cell non-regression, development gates, confirmation gates, combined gates, and score formula.
+"""
+
+import json
+import math
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+import pytest
+import torch
+
+# Ensure test directory and repo root are in Python path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+import evaluate_heavy_cross_split as evaluator
+import heavy_pso_autoresearch as autoresearch
+import heavy_pso_cross_split as runner
+import heavy_task_feasibility as heavy_task
+
+
+@pytest.fixture
+def mock_heavy_task_deps(monkeypatch):
+ """Mocks data preparation and execution functions for fast, deterministic unit testing."""
+ split_records = {}
+
+ def fake_prepare_heavy_task_data(dataset_name: str, split_seed: int = 20260902, cache_dir=None):
+ N_search, N_val = 20, 10
+ x_search = torch.randn(N_search, 1, 28, 28)
+ y_search = torch.randint(0, 10, (N_search,))
+ x_val = torch.randn(N_val, 1, 28, 28)
+ y_val = torch.randint(0, 10, (N_val,))
+ nested_subsets = {2000: torch.arange(10), 10000: torch.arange(20), 50000: torch.arange(20)}
+ data_fp = f"data-fp-{dataset_name}-{split_seed}"
+ split_fp = f"split-fp-{dataset_name}-{split_seed}"
+ split_records[dataset_name] = split_seed
+ provenance = {
+ "dataset_name": dataset_name,
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "test_samples": 0,
+ "search_samples": 50000,
+ "val_samples": 10000,
+ "split_seed": split_seed,
+ "split_fingerprint": split_fp,
+ "data_fingerprint": data_fp,
+ }
+ return x_search, y_search, x_val, y_val, nested_subsets, data_fp, provenance
+
+ monkeypatch.setattr(heavy_task, "prepare_heavy_task_data", fake_prepare_heavy_task_data)
+ monkeypatch.setattr(autoresearch, "prepare_heavy_task_data", fake_prepare_heavy_task_data)
+
+ def fake_run_v6_pso(
+ transform, base_model, x_search, y_search, x_val, y_val, nested_subsets,
+ schedule_str, epochs, swarm_size, seed, device, geom_config=None, val_check_interval=10
+ ):
+ return {
+ "val_selected_loss": 0.50,
+ "val_selected_acc": 85.0,
+ "gbest_loss": 0.48,
+ "gbest_acc": 86.0,
+ "wall_time_sec": 0.01,
+ "optimization_wall_time_sec": 0.01,
+ "validation_wall_time_sec": 0.001,
+ "total_queries": swarm_size * epochs,
+ "total_sample_evaluations": swarm_size * epochs * 10000,
+ "validation_evaluations": 2,
+ "val_metrics": {"brier": 0.1, "ece": 0.02},
+ }
+
+ def fake_run_g8_optimizer(
+ base_model, x_2k, y_2k, x_val, y_val, epochs, swarm_size, seed, device
+ ):
+ return {
+ "val_selected_loss": 0.55,
+ "val_selected_acc": 83.0,
+ "gbest_loss": 0.52,
+ "gbest_acc": 84.0,
+ "wall_time_sec": 0.01,
+ "optimization_wall_time_sec": 0.01,
+ "validation_wall_time_sec": 0.001,
+ "total_queries": swarm_size * epochs,
+ "total_sample_evaluations": swarm_size * epochs * 10000,
+ "validation_evaluations": 2,
+ "val_metrics": {"brier": 0.12, "ece": 0.03},
+ }
+
+ monkeypatch.setattr(heavy_task, "run_v6_pso", fake_run_v6_pso)
+ monkeypatch.setattr(heavy_task, "run_g8_optimizer", fake_run_g8_optimizer)
+ monkeypatch.setattr(autoresearch, "run_v6_pso", fake_run_v6_pso)
+
+ return split_records
+
+
+# =====================================================================
+# 1. Split Seed Propagation Tests
+# =====================================================================
+
+def test_split_seed_propagation(mock_heavy_task_deps):
+ """Verify alternate split seeds reach prepare_heavy_task_data across runners."""
+ res_confirm = heavy_task.run_heavy_task_confirm(
+ workloads={"mnist_compact": heavy_task.WORKLOADS["mnist_compact"]},
+ selected_methods={"mnist_compact": ["G8"]},
+ particles=2,
+ epochs=2,
+ seeds=[101],
+ split_seed=20260905,
+ )
+ assert res_confirm["mnist_compact"]["G8"]["split_seed"] == 20260905
+ assert res_confirm["mnist_compact"]["G8"]["data_fingerprint"] == "data-fp-mnist-20260905"
+
+ res_auto = autoresearch.run_heavy_pso_autoresearch(
+ ratios=[0.5],
+ particles=2,
+ epochs=2,
+ seeds=[101],
+ split_seed=20260906,
+ projection_seed_mode="explicit",
+ projection_seed=12345,
+ )
+ meta = res_auto["workloads"]["mnist_compact"]
+ assert meta["data_fingerprint"] == "data-fp-mnist-20260906"
+ assert meta["split_fingerprint"] == "split-fp-mnist-20260906"
+
+
+# =====================================================================
+# 2. Projection Seed Override Validation & Parsing Tests
+# =====================================================================
+
+def test_projection_override_validation_and_parsing():
+ """Verify per-workload projection seed dictionary validation and CLI argument parsing."""
+ # Valid dict validation
+ valid_dict = {
+ "mnist_compact": 1800044939,
+ "mnist_wide": 592157828,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 189641451,
+ }
+ autoresearch.validate_projection_seed_config("explicit", valid_dict)
+
+ # Valid CLI string parsing
+ parsed_json = autoresearch.parse_projection_seed_arg(
+ '{"mnist_compact": 1800044939, "mnist_wide": 592157828}'
+ )
+ assert parsed_json["mnist_compact"] == 1800044939
+
+ parsed_kv = autoresearch.parse_projection_seed_arg(
+ "mnist_compact:1800044939,mnist_wide:592157828"
+ )
+ assert parsed_kv["mnist_compact"] == 1800044939
+ assert parsed_kv["mnist_wide"] == 592157828
+
+ parsed_int = autoresearch.parse_projection_seed_arg("1800044939")
+ assert parsed_int == 1800044939
+
+ # Effective projection seeds in derive_projection_seed
+ s1 = autoresearch.derive_projection_seed("mnist_compact", 0.5, 101, mode="explicit", projection_seed=valid_dict)
+ s2 = autoresearch.derive_projection_seed("mnist_wide", 0.5, 101, mode="explicit", projection_seed=valid_dict)
+ assert s1 == 1800044939
+ assert s2 == 592157828
+
+ # Invalid cases
+ with pytest.raises(ValueError, match="Invalid projection_seed_mode"):
+ autoresearch.validate_projection_seed_config("invalid_mode", None)
+
+ with pytest.raises(ValueError, match="projection_seed must be provided"):
+ autoresearch.validate_projection_seed_config("explicit", None)
+
+ with pytest.raises(ValueError, match="Unknown workload_id"):
+ autoresearch.validate_projection_seed_config("explicit", {"unknown_wl": 12345})
+
+ with pytest.raises(ValueError, match="non-negative integer"):
+ autoresearch.validate_projection_seed_config(
+ "explicit",
+ {
+ "mnist_compact": -5,
+ "mnist_wide": 1800044939,
+ "fashion_compact": 1363313651,
+ "fashion_wide": 189641451,
+ },
+ )
+ with pytest.raises(ValueError, match="projection_seed can only be provided"):
+ autoresearch.validate_projection_seed_config("coupled", 12345)
+
+
+# =====================================================================
+# 3. Artifact Accounting & Provenance Tests
+# =====================================================================
+
+def test_artifact_accounting_and_provenance(mock_heavy_task_deps):
+ """Verify artifact accounting, fingerprint matching, state ratio, and official test seals."""
+ payload = runner.run_heavy_pso_cross_split(
+ phase="development",
+ particles=2,
+ epochs=2,
+ )
+ assert payload["phase"] == "development"
+ assert payload["official_test_data_loaded"] is False
+ assert payload["official_test_evaluations"] == 0
+
+ res_totals = payload["resource_totals"]
+ # 2 splits * 4 workloads * 3 seeds * 2 (baseline + candidate) = 48 runs
+ assert res_totals["total_runs"] == 48
+ # Each run has 2 particles * 2 epochs = 4 queries, 4 * 10000 = 40000 samples
+ assert res_totals["total_queries"] == 48 * 4
+ assert res_totals["total_samples_evaluated"] == 48 * 40000
+
+ # Fingerprint matching check in splits payload
+ dev_split = payload["splits"]["20260905"]
+ b_fp = dev_split["baselines"]["mnist_compact"]["data_fingerprint"]
+ c_fp = dev_split["candidates"]["mnist_compact"]["data_fingerprint"]
+ assert b_fp == c_fp, "Baseline and candidate data fingerprints must match"
+
+
+# =====================================================================
+# 4. Phase Seed Enforcement Tests
+# =====================================================================
+
+def test_cross_split_runner_phase_enforcement(mock_heavy_task_deps):
+ """Verify runner enforces exact phase split and swarm seeds."""
+ dev_payload = runner.run_heavy_pso_cross_split(phase="development", particles=2, epochs=2)
+ assert dev_payload["split_seeds"] == [20260905, 20260906]
+ assert dev_payload["swarm_seeds"] == [101, 102, 103]
+
+ conf_payload = runner.run_heavy_pso_cross_split(phase="confirmation", particles=2, epochs=2)
+ assert conf_payload["split_seeds"] == [20260907]
+ assert conf_payload["swarm_seeds"] == [111, 112, 113]
+
+ with pytest.raises(ValueError, match="Invalid phase"):
+ runner.run_heavy_pso_cross_split(phase="invalid_phase")
+
+
+def test_cross_split_cli_defaults_to_frozen_policy():
+ """The CLI must execute the frozen policy when no method flags are supplied."""
+ args = runner.build_parser().parse_args([])
+ assert args.geometry_policy == "baseline_aligned"
+ assert args.projection_scope == "global"
+ assert args.projection_seed_mode == "explicit"
+ assert args.projection_seed is None
+
+
+def test_cross_split_mixed_projection_scope(mock_heavy_task_deps):
+ """Verify cross-split runner accepts and serializes mixed projection_scope dictionary mapping."""
+ mixed_scope = {
+ "mnist_compact": "global",
+ "mnist_wide": "balanced_global",
+ "fashion_compact": "global",
+ "fashion_wide": "balanced_global",
+ }
+ payload = runner.run_heavy_pso_cross_split(
+ phase="development",
+ projection_scope=mixed_scope,
+ particles=2,
+ epochs=2,
+ )
+ assert payload["candidate_config"]["projection_scope"] == mixed_scope
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "global"
+ assert payload["workloads"]["mnist_wide"]["projection_scope"] == "balanced_global"
+
+ dev_split = payload["splits"]["20260905"]
+ assert dev_split["candidates"]["mnist_compact"]["projection_scope"] == "global"
+ assert dev_split["candidates"]["mnist_wide"]["projection_scope"] == "balanced_global"
+
+
+def test_cross_split_mixed_projection_scope_two_hash(mock_heavy_task_deps):
+ """Verify cross-split runner accepts and serializes mixed projection_scope dictionary mapping with two_hash_global on Wide."""
+ mixed_scope = {
+ "mnist_compact": "global",
+ "mnist_wide": "two_hash_global",
+ "fashion_compact": "global",
+ "fashion_wide": "two_hash_global",
+ }
+ payload = runner.run_heavy_pso_cross_split(
+ phase="development",
+ projection_scope=mixed_scope,
+ particles=2,
+ epochs=2,
+ )
+ assert payload["candidate_config"]["projection_scope"] == mixed_scope
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "global"
+ assert payload["workloads"]["mnist_wide"]["projection_scope"] == "two_hash_global"
+
+ dev_split = payload["splits"]["20260905"]
+ assert dev_split["candidates"]["mnist_compact"]["projection_scope"] == "global"
+ assert dev_split["candidates"]["mnist_wide"]["projection_scope"] == "two_hash_global"
+
+
+def test_cross_split_mixed_projection_scope_largest_tensor_hash(mock_heavy_task_deps):
+ """Verify cross-split runner accepts and serializes mixed projection_scope dictionary mapping with largest_tensor_hash on Wide."""
+ mixed_scope = {
+ "mnist_compact": "global",
+ "mnist_wide": "largest_tensor_hash",
+ "fashion_compact": "global",
+ "fashion_wide": "largest_tensor_hash",
+ }
+ payload = runner.run_heavy_pso_cross_split(
+ phase="development",
+ projection_scope=mixed_scope,
+ particles=2,
+ epochs=2,
+ )
+ assert payload["candidate_config"]["projection_scope"] == mixed_scope
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "global"
+ assert payload["workloads"]["mnist_wide"]["projection_scope"] == "largest_tensor_hash"
+
+ dev_split = payload["splits"]["20260905"]
+ assert dev_split["candidates"]["mnist_compact"]["projection_scope"] == "global"
+ assert dev_split["candidates"]["mnist_wide"]["projection_scope"] == "largest_tensor_hash"
+def test_cross_split_mixed_projection_scope_largest_tensor_row_hash(mock_heavy_task_deps):
+ """Verify cross-split runner accepts and serializes mixed projection_scope dictionary mapping with largest_tensor_row_hash on Wide."""
+ mixed_scope = {
+ "mnist_compact": "global",
+ "mnist_wide": "largest_tensor_row_hash",
+ "fashion_compact": "global",
+ "fashion_wide": "largest_tensor_row_hash",
+ }
+ payload = runner.run_heavy_pso_cross_split(
+ phase="development",
+ projection_scope=mixed_scope,
+ particles=2,
+ epochs=2,
+ )
+ assert payload["candidate_config"]["projection_scope"] == mixed_scope
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "global"
+ assert payload["workloads"]["mnist_wide"]["projection_scope"] == "largest_tensor_row_hash"
+
+ dev_split = payload["splits"]["20260905"]
+ assert dev_split["candidates"]["mnist_compact"]["projection_scope"] == "global"
+ assert dev_split["candidates"]["mnist_wide"]["projection_scope"] == "largest_tensor_row_hash"
+def test_cross_split_mixed_projection_scope_adjacent_pair(mock_heavy_task_deps):
+ """Verify cross-split runner accepts and serializes mixed projection_scope dictionary mapping with adjacent_pair on Wide."""
+ mixed_scope = {
+ "mnist_compact": "global",
+ "mnist_wide": "adjacent_pair",
+ "fashion_compact": "global",
+ "fashion_wide": "adjacent_pair",
+ }
+ payload = runner.run_heavy_pso_cross_split(
+ phase="development",
+ projection_scope=mixed_scope,
+ particles=2,
+ epochs=2,
+ )
+ assert payload["candidate_config"]["projection_scope"] == mixed_scope
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "global"
+ assert payload["workloads"]["mnist_wide"]["projection_scope"] == "adjacent_pair"
+
+ dev_split = payload["splits"]["20260905"]
+ assert dev_split["candidates"]["mnist_compact"]["projection_scope"] == "global"
+ assert dev_split["candidates"]["mnist_wide"]["projection_scope"] == "adjacent_pair"
+def test_cross_split_mixed_projection_scope_adjacent_difference(mock_heavy_task_deps):
+ """Verify cross-split runner accepts and serializes mixed projection_scope dictionary mapping with adjacent_difference on Wide."""
+ mixed_scope = {
+ "mnist_compact": "global",
+ "mnist_wide": "adjacent_difference",
+ "fashion_compact": "global",
+ "fashion_wide": "adjacent_difference",
+ }
+ payload = runner.run_heavy_pso_cross_split(
+ phase="development",
+ projection_scope=mixed_scope,
+ particles=2,
+ epochs=2,
+ )
+ assert payload["candidate_config"]["projection_scope"] == mixed_scope
+ assert payload["workloads"]["mnist_compact"]["projection_scope"] == "global"
+ assert payload["workloads"]["mnist_wide"]["projection_scope"] == "adjacent_difference"
+
+ dev_split = payload["splits"]["20260905"]
+ assert dev_split["candidates"]["mnist_compact"]["projection_scope"] == "global"
+ assert dev_split["candidates"]["mnist_wide"]["projection_scope"] == "adjacent_difference"
+
+# =====================================================================
+# 5. Evaluator Hard Gates & Score Calculation Tests
+# =====================================================================
+
+def create_synthetic_artifact(
+ phase: str,
+ acc_delta: float = 2.0,
+ nll_delta: float = -0.10,
+) -> Dict[str, Any]:
+ split_seeds = [20260905, 20260906] if phase == "development" else [20260907]
+ swarm_seeds = [101, 102, 103] if phase == "development" else [111, 112, 113]
+ projection_seeds = dict(runner.FROZEN_PROJECTION_SEEDS)
+ splits = {}
+ for split_seed in split_seeds:
+ baselines = {}
+ candidates = {}
+ for workload in evaluator.WORKLOADS:
+ total_dim = evaluator.TOTAL_DIMS[workload]
+ latent_dim = evaluator.compute_latent_dim(total_dim, 0.5)
+ baseline_states = 5 * 12 + (
+ 1 if evaluator.BASELINE_METHODS[workload] == "G8" else 0
+ )
+ baseline_bytes = baseline_states * total_dim * 4
+ candidate_bytes = evaluator.compute_core_swarm_state_bytes(12, latent_dim)
+ baseline_runs = []
+ candidate_runs = []
+ for seed in swarm_seeds:
+ common = {
+ "seed": seed,
+ "gbest_loss": 0.55,
+ "gbest_acc": 79.0,
+ "wall_time_sec": 1.0,
+ "optimization_wall_time_sec": 0.9,
+ "validation_wall_time_sec": 0.1,
+ "total_queries": 960,
+ "total_sample_evaluations": 9_600_000,
+ "validation_evaluations": 8,
+ "official_test_evaluations": 0,
+ "throughput_samples_per_sec": 10_666_666.0,
+ }
+ baseline_runs.append(
+ {
+ **common,
+ "val_selected_loss": 0.60,
+ "val_selected_acc": 80.0,
+ "val_metrics": {"nll": 0.60, "brier": 0.20, "ece": 0.05},
+ "core_swarm_state_bytes": baseline_bytes,
+ }
+ )
+ candidate_runs.append(
+ {
+ **common,
+ "projection_seed": projection_seeds[workload],
+ "projection_scope": "global",
+ "projection_seed_mode": "explicit",
+ "geometry_multiplier": 1.0,
+ "val_selected_loss": 0.60 + nll_delta,
+ "val_selected_acc": 80.0 + acc_delta,
+ "val_metrics": {
+ "nll": 0.60 + nll_delta,
+ "brier": 0.18,
+ "ece": 0.04,
+ },
+ "core_swarm_state_bytes": candidate_bytes,
+ "is_finite": True,
+ }
+ )
+ fingerprint = f"fp-{workload}-{split_seed}"
+ shared_entry = {
+ "workload_id": workload,
+ "split_seed": split_seed,
+ "data_fingerprint": fingerprint,
+ "split_fingerprint": f"split-{workload}-{split_seed}",
+ "subset_size": 10_000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": list(swarm_seeds),
+ }
+ baselines[workload] = {
+ **shared_entry,
+ "method_id": evaluator.BASELINE_METHODS[workload],
+ "stats": {
+ "val_acc": {"mean": 80.0},
+ "val_nll": {"mean": 0.60},
+ },
+ "per_seed_runs": baseline_runs,
+ }
+ candidates[workload] = {
+ **shared_entry,
+ "candidate_id": "pexplicit_aligned_r0.5",
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "geometry_multiplier": 1.0,
+ "projection_scope": "global",
+ "projection_seed_mode": "explicit",
+ "projection_seed": projection_seeds[workload],
+ "total_dim": total_dim,
+ "latent_dim": latent_dim,
+ "state_ratio": candidate_bytes / baseline_bytes,
+ "core_swarm_state_bytes": candidate_bytes,
+ "baseline_core_swarm_state_bytes": baseline_bytes,
+ "stats": {
+ "val_acc": {"mean": 80.0 + acc_delta},
+ "val_nll": {"mean": 0.60 + nll_delta},
+ },
+ "per_seed_runs": candidate_runs,
+ }
+ splits[str(split_seed)] = {
+ "split_seed": split_seed,
+ "baselines": baselines,
+ "candidates": candidates,
+ }
+ total_runs = len(split_seeds) * 4 * len(swarm_seeds) * 2
+ return {
+ "version": runner.PROTOCOL_VERSION,
+ "protocol_version": runner.PROTOCOL_VERSION,
+ "phase": phase,
+ "split_seeds": split_seeds,
+ "swarm_seeds": swarm_seeds,
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "candidate_config": {
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "projection_scope": "global",
+ "projection_seed_mode": "explicit",
+ "projection_seed": projection_seeds,
+ "geometry_multiplier": 1.0,
+ "particles": 12,
+ "epochs": 80,
+ "subset_size": 10_000,
+ },
+ "workloads": {
+ workload: {
+ "workload_id": workload,
+ "dataset_name": (
+ "mnist" if workload.startswith("mnist") else "fashion_mnist"
+ ),
+ "model_name": (
+ "compact_cnn" if workload.endswith("compact") else "wide_cnn"
+ ),
+ "baseline_method": evaluator.BASELINE_METHODS[workload],
+ "effective_projection_seed": projection_seeds[workload],
+ }
+ for workload in evaluator.WORKLOADS
+ },
+ "splits": splits,
+ "resource_totals": {
+ "total_runs": total_runs,
+ "total_queries": total_runs * 960,
+ "total_samples_evaluated": total_runs * 9_600_000,
+ "official_test_evaluations": 0,
+ "wall_time_sec": 1.0,
+ },
+ }
+
+
+def test_evaluator_all_gates_and_score():
+ """Verify evaluator passes valid dev + conf artifacts and rejects violations."""
+ dev_art = create_synthetic_artifact("development", acc_delta=2.5, nll_delta=-0.05)
+ conf_art = create_synthetic_artifact("confirmation", acc_delta=2.5, nll_delta=-0.05)
+
+ res_pass = evaluator.evaluate_heavy_cross_split(dev_art, conf_art)
+ assert res_pass["pass"] is True
+ assert res_pass["failed_hard_gate_count"] == 0
+ assert res_pass["score"] > 0
+
+ # Test missing confirmation artifact rejection
+ res_no_conf = evaluator.evaluate_heavy_cross_split(dev_art, None)
+ assert res_no_conf["pass"] is False
+ assert "confirmation_executed" in res_no_conf["failed_gates"]
+ assert res_no_conf["failed_hard_gate_count"] > 0
+
+ # Test test leakage rejection
+ dev_leak = create_synthetic_artifact("development")
+ dev_leak["official_test_data_loaded"] = True
+ res_leak = evaluator.evaluate_heavy_cross_split(dev_leak, conf_art)
+ assert res_leak["pass"] is False
+ assert "official_test_sealed" in res_leak["failed_gates"]
+
+ # Test non-finite metric rejection
+ dev_inf = create_synthetic_artifact("development")
+ dev_inf["splits"]["20260905"]["candidates"]["mnist_compact"]["per_seed_runs"][0]["val_selected_loss"] = float("nan")
+ res_inf = evaluator.evaluate_heavy_cross_split(dev_inf, conf_art)
+ assert res_inf["pass"] is False
+ assert "all_runs_finite" in res_inf["failed_gates"]
+
+ # Test fingerprint mismatch rejection
+ dev_fp_mismatch = create_synthetic_artifact("development")
+ dev_fp_mismatch["splits"]["20260905"]["candidates"]["mnist_compact"]["split_fingerprint"] = "bad-fp"
+ res_fp_mismatch = evaluator.evaluate_heavy_cross_split(dev_fp_mismatch, conf_art)
+ assert res_fp_mismatch["pass"] is False
+ assert "split_and_fingerprint_matched" in res_fp_mismatch["failed_gates"]
+
+ # Test per-cell accuracy regression violation (> 1.0 pp)
+ dev_reg = create_synthetic_artifact("development", acc_delta=-1.5, nll_delta=0.0)
+ res_reg = evaluator.evaluate_heavy_cross_split(dev_reg, conf_art)
+ assert res_reg["pass"] is False
+ assert "maximum_accuracy_regression_percentage_points_each_split_workload" in res_reg["failed_gates"]
+
+
+def test_evaluator_accepts_development_only_as_confirmation_eligible():
+ development = create_synthetic_artifact(
+ "development", acc_delta=2.5, nll_delta=-0.05
+ )
+ result = evaluator.evaluate_heavy_cross_split(development)
+ assert result["pass"] is False
+ assert result["development_pass"] is True
+ assert result["eligible_for_confirmation"] is True
+ assert result["score_failed_gate_count"] == 0
+
+
+def test_evaluator_rejects_missing_or_inconsistent_evidence():
+ development = create_synthetic_artifact(
+ "development", acc_delta=2.5, nll_delta=-0.05
+ )
+ confirmation = create_synthetic_artifact(
+ "confirmation", acc_delta=2.5, nll_delta=-0.05
+ )
+
+ missing_fingerprint = create_synthetic_artifact(
+ "development", acc_delta=2.5, nll_delta=-0.05
+ )
+ del missing_fingerprint["splits"]["20260905"]["candidates"]["mnist_compact"][
+ "data_fingerprint"
+ ]
+ result = evaluator.evaluate_heavy_cross_split(
+ missing_fingerprint, confirmation
+ )
+ assert "split_and_fingerprint_matched" in result["failed_gates"]
+
+ inconsistent_stats = create_synthetic_artifact(
+ "development", acc_delta=2.5, nll_delta=-0.05
+ )
+ inconsistent_stats["splits"]["20260905"]["candidates"]["mnist_compact"][
+ "stats"
+ ]["val_acc"]["mean"] += 1.0
+ result = evaluator.evaluate_heavy_cross_split(
+ inconsistent_stats, confirmation
+ )
+ assert "schema_and_phase_seeds" in result["failed_gates"]
+
+ confirmation["candidate_config"]["ratio"] = 0.25
+ result = evaluator.evaluate_heavy_cross_split(development, confirmation)
+ assert "configuration_and_policy_matched" in result["failed_gates"]
+def test_evaluator_rejects_missing_selected_metrics():
+ conf_art = create_synthetic_artifact("confirmation", acc_delta=2.5, nll_delta=-0.05)
+
+ for metric in ("val_selected_acc", "val_selected_loss"):
+ # Test key deletion
+ dev_art_del = create_synthetic_artifact("development", acc_delta=2.5, nll_delta=-0.05)
+ run_del = dev_art_del["splits"]["20260905"]["candidates"]["mnist_compact"]["per_seed_runs"][0]
+ del run_del[metric]
+ result_del = evaluator.evaluate_heavy_cross_split(dev_art_del, conf_art)
+ assert result_del["pass"] is False
+ assert result_del["failed_hard_gate_count"] > 0
+ assert (
+ "schema_and_phase_seeds" in result_del["failed_gates"]
+ or "all_runs_finite" in result_del["failed_gates"]
+ )
+
+ # Test non-numeric string
+ dev_art_str = create_synthetic_artifact("development", acc_delta=2.5, nll_delta=-0.05)
+ run_str = dev_art_str["splits"]["20260905"]["candidates"]["mnist_compact"]["per_seed_runs"][0]
+ run_str[metric] = "invalid_string"
+ result_str = evaluator.evaluate_heavy_cross_split(dev_art_str, conf_art)
+ assert result_str["pass"] is False
+ assert result_str["failed_hard_gate_count"] > 0
+ assert (
+ "schema_and_phase_seeds" in result_str["failed_gates"]
+ or "all_runs_finite" in result_str["failed_gates"]
+ )
+
+ # Test None
+ dev_art_none = create_synthetic_artifact("development", acc_delta=2.5, nll_delta=-0.05)
+ run_none = dev_art_none["splits"]["20260905"]["candidates"]["mnist_compact"]["per_seed_runs"][0]
+ run_none[metric] = None
+ result_none = evaluator.evaluate_heavy_cross_split(dev_art_none, conf_art)
+ assert result_none["pass"] is False
+ assert result_none["failed_hard_gate_count"] > 0
+ assert (
+ "schema_and_phase_seeds" in result_none["failed_gates"]
+ or "all_runs_finite" in result_none["failed_gates"]
+ )
diff --git a/tests/test_heavy_task_feasibility.py b/tests/test_heavy_task_feasibility.py
new file mode 100644
index 0000000..8d83caf
--- /dev/null
+++ b/tests/test_heavy_task_feasibility.py
@@ -0,0 +1,368 @@
+"""
+Unit tests for Heavy Task Feasibility Study (MNIST & FashionMNIST).
+
+Covers:
+1. Exact model parameter counts and forward shapes (CompactCNN vs WideCNN)
+2. Immutable workload matrix definitions (mnist_compact, mnist_wide, fashion_compact, fashion_wide)
+3. Train-only loader guard for both datasets (train=True only, test_samples=0, test_evals=0)
+4. Deterministic normalized-method selection logic (G0, G5, G6)
+5. Feasibility threshold boundaries (execution_feasible and optimization_feasible)
+6. Finite and artifact schema properties
+7. Exact fixed2k/fixed10k query, sample evaluation, and swarm state accounting
+8. CPU smoke runner execution without network
+"""
+
+import math
+import sys
+from pathlib import Path
+
+import pytest
+import torch
+import torch.nn as nn
+
+# Ensure test directory and repo root are in Python path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+import heavy_task_feasibility as heavy_task
+
+
+@pytest.fixture
+def synthetic_heavy_data(monkeypatch):
+ """Keep runner tests deterministic and independent of dataset downloads."""
+ x_search = torch.zeros(100, 1, 28, 28)
+ y_search = torch.arange(100) % 10
+ x_val = torch.zeros(100, 1, 28, 28)
+ y_val = torch.arange(100) % 10
+ nested_subsets = {
+ size: torch.arange(size) % len(y_search)
+ for size in (2000, 10000, 50000)
+ }
+
+ def fake_prepare(dataset_name, split_seed=20260902, cache_dir=None):
+ provenance = {
+ "dataset_name": dataset_name,
+ "official_test_data_loaded": False,
+ "official_test_evaluations": 0,
+ "test_samples": 0,
+ "search_samples": 50000,
+ "val_samples": 10000,
+ "split_fingerprint": "synthetic-split",
+ "data_fingerprint": "synthetic-data",
+ }
+ return (
+ x_search,
+ y_search,
+ x_val,
+ y_val,
+ nested_subsets,
+ "synthetic-data",
+ provenance,
+ )
+
+ monkeypatch.setattr(heavy_task, "prepare_heavy_task_data", fake_prepare)
+
+
+from heavy_task_feasibility import (
+ PROTOCOL_VERSION,
+ WORKLOADS,
+ HEAVY_METHODS,
+ CompactCNN,
+ WideCNN,
+ make_compact_cnn,
+ make_wide_cnn,
+ create_model,
+ prepare_heavy_task_data,
+ evaluate_untrained_baseline,
+ select_best_normalized_method,
+ evaluate_feasibility,
+ run_heavy_task_screen,
+ run_heavy_task_confirm,
+ run_heavy_task_study,
+ WorkloadConfig,
+)
+
+
+# =====================================================================
+# 1. Parameter Counts & Forward Shapes
+# =====================================================================
+
+def test_exact_model_parameter_counts_and_forward_shapes():
+ compact_model = make_compact_cnn(seed=41)
+ compact_params = sum(p.numel() for p in compact_model.parameters())
+ assert compact_params == 9098, f"CompactCNN should have 9,098 parameters, got {compact_params}"
+
+ wide_model = make_wide_cnn(seed=41)
+ wide_params = sum(p.numel() for p in wide_model.parameters())
+ assert wide_params == 55338, f"WideCNN should have 55,338 parameters, got {wide_params}"
+
+ # Forward shape test with (B, 1, 28, 28)
+ x_img = torch.randn(2, 1, 28, 28)
+ out_c_img = compact_model(x_img)
+ out_w_img = wide_model(x_img)
+ assert out_c_img.shape == (2, 10), f"CompactCNN image output shape should be (2, 10), got {out_c_img.shape}"
+ assert out_w_img.shape == (2, 10), f"WideCNN image output shape should be (2, 10), got {out_w_img.shape}"
+
+ # Forward shape test with flattened (B, 784)
+ x_flat = torch.randn(2, 784)
+ out_c_flat = compact_model(x_flat)
+ out_w_flat = wide_model(x_flat)
+ assert out_c_flat.shape == (2, 10), f"CompactCNN flat output shape should be (2, 10), got {out_c_flat.shape}"
+ assert out_w_flat.shape == (2, 10), f"WideCNN flat output shape should be (2, 10), got {out_w_flat.shape}"
+
+ # Deterministic factory behavior
+ c1 = make_compact_cnn(seed=41)
+ c2 = make_compact_cnn(seed=41)
+ for p1, p2 in zip(c1.parameters(), c2.parameters()):
+ assert torch.equal(p1, p2)
+
+ w1 = make_wide_cnn(seed=41)
+ w2 = make_wide_cnn(seed=41)
+ for p1, p2 in zip(w1.parameters(), w2.parameters()):
+ assert torch.equal(p1, p2)
+
+
+# =====================================================================
+# 2. Immutable Workload Matrix
+# =====================================================================
+
+def test_immutable_workload_matrix():
+ expected_workloads = {"mnist_compact", "mnist_wide", "fashion_compact", "fashion_wide"}
+ assert set(WORKLOADS.keys()) == expected_workloads
+
+ assert WORKLOADS["mnist_compact"].dataset_name == "mnist"
+ assert WORKLOADS["mnist_compact"].model_name == "compact_cnn"
+
+ assert WORKLOADS["mnist_wide"].dataset_name == "mnist"
+ assert WORKLOADS["mnist_wide"].model_name == "wide_cnn"
+
+ assert WORKLOADS["fashion_compact"].dataset_name == "fashion_mnist"
+ assert WORKLOADS["fashion_compact"].model_name == "compact_cnn"
+
+ assert WORKLOADS["fashion_wide"].dataset_name == "fashion_mnist"
+ assert WORKLOADS["fashion_wide"].model_name == "wide_cnn"
+
+ assert HEAVY_METHODS == ["G0", "G5", "G6", "G8"]
+
+
+# =====================================================================
+# 3. Train-Only Loader Guard
+# =====================================================================
+
+def test_train_only_loader_guard(monkeypatch, tmp_path):
+ import torchvision.datasets
+
+ calls = []
+
+ class DatasetConstructionStopped(Exception):
+ pass
+
+ def reject_after_recording(name):
+ def constructor(*, root, train, download):
+ calls.append((name, train, download))
+ raise DatasetConstructionStopped
+ return constructor
+
+ monkeypatch.setattr(
+ torchvision.datasets,
+ "MNIST",
+ reject_after_recording("mnist"),
+ )
+ monkeypatch.setattr(
+ torchvision.datasets,
+ "FashionMNIST",
+ reject_after_recording("fashion_mnist"),
+ )
+
+ for dataset_name in ("mnist", "fashion_mnist"):
+ with pytest.raises(DatasetConstructionStopped):
+ prepare_heavy_task_data(
+ dataset_name=dataset_name,
+ split_seed=20260902,
+ cache_dir=tmp_path,
+ )
+
+ assert calls == [
+ ("mnist", True, True),
+ ("fashion_mnist", True, True),
+ ]
+
+
+# =====================================================================
+# 4. Deterministic Normalized Method Selection
+# =====================================================================
+
+def test_deterministic_normalized_method_selection():
+ mock_screen_results = [
+ {"method_id": "G0", "val_selected_loss": 0.60, "val_selected_acc": 82.0},
+ {"method_id": "G5", "val_selected_loss": 0.50, "val_selected_acc": 84.0},
+ {"method_id": "G6", "val_selected_loss": 0.52, "val_selected_acc": 84.5},
+ {"method_id": "G8", "val_selected_loss": 0.45, "val_selected_acc": 85.0},
+ ]
+ # G8 is excluded from normalized custom selection; G5 has lowest val_selected_loss (0.50)
+ best_m = select_best_normalized_method(mock_screen_results)
+ assert best_m == "G5"
+
+ # Test tiebreak logic: same loss, pick higher accuracy
+ mock_tie = [
+ {"method_id": "G0", "val_selected_loss": 0.50, "val_selected_acc": 83.0},
+ {"method_id": "G5", "val_selected_loss": 0.50, "val_selected_acc": 85.0},
+ {"method_id": "G6", "val_selected_loss": 0.50, "val_selected_acc": 84.0},
+ ]
+ best_tie = select_best_normalized_method(mock_tie)
+ assert best_tie == "G5"
+
+ # Diverged candidates cannot win selection; fail explicitly if none are finite.
+ with_nonfinite = [
+ {"method_id": "G0", "val_selected_loss": float("nan"), "val_selected_acc": 99.0},
+ {"method_id": "G5", "val_selected_loss": 0.60, "val_selected_acc": 82.0},
+ {"method_id": "G6", "val_selected_loss": float("inf"), "val_selected_acc": 100.0},
+ ]
+ assert select_best_normalized_method(with_nonfinite) == "G5"
+ with pytest.raises(ValueError, match="No finite normalized method"):
+ select_best_normalized_method(with_nonfinite[:1])
+
+
+# =====================================================================
+# 5. Feasibility Threshold Boundaries
+# =====================================================================
+
+def test_feasibility_threshold_boundaries():
+ baseline_nll = 2.30
+ baseline_acc = 10.0
+
+ # 1. Non-finite run
+ bad_runs = [{"val_selected_loss": float("nan"), "val_selected_acc": 50.0}]
+ f1 = evaluate_feasibility(bad_runs, baseline_nll, baseline_acc)
+ assert f1["execution_feasible"] is False
+ assert f1["optimization_feasible"] is False
+
+ # 2. Feasible run passing both NLL and accuracy thresholds
+ # Target NLL <= 2.30 * 0.80 = 1.84
+ # Target Acc >= 10.0 + 20.0 = 30.0
+ good_runs = [
+ {"val_selected_loss": 1.50, "val_selected_acc": 40.0},
+ {"val_selected_loss": 1.60, "val_selected_acc": 42.0},
+ ]
+ f2 = evaluate_feasibility(good_runs, baseline_nll, baseline_acc)
+ assert f2["execution_feasible"] is True
+ assert f2["optimization_feasible"] is True
+ assert f2["target_val_nll_threshold"] == 1.84
+ assert f2["target_val_acc_threshold"] == 30.0
+
+ # 3. Failing NLL threshold (1.90 > 1.84)
+ fail_nll_runs = [
+ {"val_selected_loss": 1.90, "val_selected_acc": 40.0},
+ ]
+ f3 = evaluate_feasibility(fail_nll_runs, baseline_nll, baseline_acc)
+ assert f3["execution_feasible"] is True
+ assert f3["optimization_feasible"] is False
+
+ # 4. Failing Acc threshold (25.0 < 30.0)
+ fail_acc_runs = [
+ {"val_selected_loss": 1.50, "val_selected_acc": 25.0},
+ ]
+ f4 = evaluate_feasibility(fail_acc_runs, baseline_nll, baseline_acc)
+ assert f4["execution_feasible"] is True
+ assert f4["optimization_feasible"] is False
+
+
+# =====================================================================
+# 6. Artifact Schema & Properties
+# =====================================================================
+
+def test_finite_and_artifact_schema(tmp_path, synthetic_heavy_data):
+ device = torch.device("cpu")
+ # Quick smoke call to test output schema structure
+ single_wl = {"mnist_compact": WORKLOADS["mnist_compact"]}
+ screen_results, baselines, meta = run_heavy_task_screen(
+ workloads=single_wl,
+ methods=["G0"],
+ particles=2,
+ epochs=2,
+ seed=91,
+ device=device,
+ cache_dir=tmp_path / "cache",
+ )
+ assert len(screen_results) == 1
+ cell = screen_results[0]
+ assert cell["official_test_evaluations"] == 0
+ assert cell["is_finite"] is True
+ assert "core_swarm_state_bytes" in cell
+ assert cell["core_swarm_state_bytes"] == 5 * 2 * 9098 * 4
+
+
+# =====================================================================
+# 7. Exact Fixed Accounting
+# =====================================================================
+
+def test_exact_fixed_accounting():
+ # Fixed 2k screening cell: 12 particles, 40 epochs
+ particles = 12
+ epochs = 40
+ subset_2k = 2000
+
+ expected_queries_2k = particles * epochs
+ expected_sample_evals_2k = expected_queries_2k * subset_2k
+
+ assert expected_queries_2k == 480
+ assert expected_sample_evals_2k == 960000
+
+ # Swarm state bytes:
+ # Custom method (G0, G5, G6): 5 * particles * param_count * 4
+ # G8 (public Optimizer): (5 * particles + 1) * param_count * 4
+ compact_params = 9098
+ custom_bytes = 5 * 12 * compact_params * 4
+ g8_bytes = (5 * 12 + 1) * compact_params * 4
+
+ assert custom_bytes == 2183520
+ assert g8_bytes == 2219912
+
+
+# =====================================================================
+# 8. CPU Smoke Runner Execution
+# =====================================================================
+
+def test_cpu_smoke_runner(tmp_path, synthetic_heavy_data):
+ device = torch.device("cpu")
+ single_wl = {"mnist_compact": WORKLOADS["mnist_compact"]}
+
+ # Screening phase smoke
+ screen_res, baselines, wl_meta = run_heavy_task_screen(
+ workloads=single_wl,
+ methods=["G0", "G8"],
+ particles=2,
+ epochs=2,
+ seed=91,
+ device=device,
+ cache_dir=tmp_path / "cache",
+ )
+ assert len(screen_res) == 2
+
+ # Confirmation phase smoke
+ selected_methods = {"mnist_compact": ["G0", "G8"]}
+ confirm_res = run_heavy_task_confirm(
+ workloads=single_wl,
+ selected_methods=selected_methods,
+ particles=2,
+ epochs=2,
+ seeds=[101, 102],
+ device=device,
+ cache_dir=tmp_path / "cache",
+ )
+ assert "mnist_compact" in confirm_res
+ assert "G0" in confirm_res["mnist_compact"]
+ assert "G8" in confirm_res["mnist_compact"]
+
+ # Feasibility smoke
+ base = baselines["mnist_compact"]
+ feas = evaluate_feasibility(
+ confirm_res["mnist_compact"]["G0"]["per_seed_runs"],
+ base["val_nll"],
+ base["val_accuracy"],
+ )
+ assert "execution_feasible" in feas
+ assert "optimization_feasible" in feas
diff --git a/tests/test_optimizer.py b/tests/test_optimizer.py
new file mode 100644
index 0000000..bd1d08e
--- /dev/null
+++ b/tests/test_optimizer.py
@@ -0,0 +1,1628 @@
+import collections
+import json
+import math
+import os
+import pytest
+import torch
+import torch.nn as nn
+
+import pso
+from pso.optimizer import Optimizer, resolve_device
+from pso.particle import Particle
+
+def test_basic_fit_and_inspection_contract(model_factory, xor_data):
+ """Verify inspection methods return None before fit, and valid objects after fit."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ opt = Optimizer(model, loss, task="binary", n_particles=2, seed=42)
+
+ # Before fit
+ assert opt.get_best_model() is None
+ assert opt.get_best_score() is None
+ assert opt.get_best_state_dict() is None
+
+ score = opt.fit(x, y, epochs=2)
+
+ # Fit return value check
+ assert isinstance(score, tuple)
+ assert len(score) == 3
+ assert all(isinstance(val, float) and math.isfinite(val) for val in score)
+
+ # get_best_score check
+ best_score = opt.get_best_score()
+ assert best_score == score
+
+ # get_best_model check
+ best_model = opt.get_best_model()
+ assert isinstance(best_model, nn.Module)
+ assert not best_model.training # Model is in eval mode
+
+ # get_best_state_dict check
+ state_dict = opt.get_best_state_dict()
+ assert isinstance(state_dict, collections.OrderedDict)
+
+ # All state dict tensors are CPU clones
+ for k, v in state_dict.items():
+ assert isinstance(v, torch.Tensor)
+ assert v.device.type == "cpu"
+
+ # Mutating returned model parameters does NOT mutate stored state dict
+ for p in best_model.parameters():
+ p.data.add_(1.0)
+
+ fresh_state_dict = opt.get_best_state_dict()
+ assert fresh_state_dict is not None
+ for k in state_dict:
+ assert torch.equal(state_dict[k], fresh_state_dict[k])
+
+
+def test_seeded_reproducibility_and_swarm_variability(model_factory, xor_data):
+ """Verify seeded runs produce identical results while individual swarm particles vary."""
+ x, y = xor_data
+ loss = nn.BCEWithLogitsLoss()
+
+ m1 = model_factory()
+ m2 = model_factory()
+
+ opt1 = Optimizer(m1, loss, task="binary", n_particles=3, seed=42)
+ opt2 = Optimizer(m2, loss, task="binary", n_particles=3, seed=42)
+
+ score1 = opt1.fit(x, y, epochs=3)
+ score2 = opt2.fit(x, y, epochs=3)
+
+ assert score1 == score2
+
+ sd1 = opt1.get_best_state_dict()
+ sd2 = opt2.get_best_state_dict()
+ assert sd1 is not None and sd2 is not None
+ for k in sd1:
+ assert torch.equal(sd1[k], sd2[k])
+
+ # Swarm variability within opt1
+ p0 = opt1.particles[0]
+ p1 = opt1.particles[1]
+ assert not torch.equal(p0.velocity, p1.velocity)
+ assert not torch.equal(p0.position, p1.position)
+
+
+def test_sequential_optimizers_independence(model_factory, xor_data):
+ """Verify sequential optimizers with different model shapes do not leak state."""
+ x, y = xor_data
+ loss = nn.BCEWithLogitsLoss()
+
+ m4 = model_factory(units=4)
+ opt4 = Optimizer(m4, loss, task="binary", n_particles=2, seed=42)
+ opt4.fit(x, y, epochs=2)
+ sd4 = opt4.get_best_state_dict()
+ assert sd4 is not None
+
+ m8 = model_factory(units=8)
+ opt8 = Optimizer(m8, loss, task="binary", n_particles=2, seed=42)
+ opt8.fit(x, y, epochs=2)
+ sd8 = opt8.get_best_state_dict()
+ assert sd8 is not None
+
+ assert sd4["0.weight"].shape == torch.Size([4, 2])
+ assert sd8["0.weight"].shape == torch.Size([8, 2])
+
+def test_multi_batch_evaluation_contract(model_factory, xor_data, monkeypatch):
+ """Verify all particles evaluate identical batch tensors in particle-outer order during swarm iterations."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ opt = Optimizer(model, loss, task="binary", n_particles=3, seed=42)
+
+ recorded_batches = []
+ original_eval = opt._evaluate_batch_tensors
+
+ def mock_eval(x_batch, y_batch):
+ recorded_batches.append((x_batch.detach().cpu(), y_batch.detach().cpu()))
+ return original_eval(x_batch, y_batch)
+
+ monkeypatch.setattr(opt, "_evaluate_batch_tensors", mock_eval)
+
+ opt.fit(x, y, epochs=1, batch_size=2)
+
+ # 4 samples, batch_size 2 -> 2 batches
+ # 3 particles evaluated over 2 batches -> 6 recorded calls total
+ assert len(recorded_batches) == 6
+
+ # Particle-outer order: Particle 0 (calls 0, 1), Particle 1 (calls 2, 3), Particle 2 (calls 4, 5)
+ # Batch 0 (calls 0, 2, 4) must receive identical x_batch and y_batch
+ assert torch.equal(recorded_batches[0][0], recorded_batches[2][0])
+ assert torch.equal(recorded_batches[0][0], recorded_batches[4][0])
+ assert torch.equal(recorded_batches[0][1], recorded_batches[2][1])
+ assert torch.equal(recorded_batches[0][1], recorded_batches[4][1])
+
+ # Batch 1 (calls 1, 3, 5) must receive identical x_batch and y_batch
+ assert torch.equal(recorded_batches[1][0], recorded_batches[3][0])
+ assert torch.equal(recorded_batches[1][0], recorded_batches[5][0])
+
+
+def test_zero_loss_succeeds_and_contextual_nonfinite_raises(model_factory, xor_data, monkeypatch):
+ x, y = xor_data
+
+ # Zero init model -> deterministic constant output
+ model_zero = model_factory(zero_init=True)
+ loss = nn.BCEWithLogitsLoss()
+ opt_zero = Optimizer(model_zero, loss, task="binary", n_particles=2, seed=42)
+
+ score_zero = opt_zero.fit(x, y, epochs=2)
+ assert all(math.isfinite(val) for val in score_zero)
+
+ # Non-finite score raises FloatingPointError
+ model = model_factory()
+ opt_nan = Optimizer(model, loss, task="binary", n_particles=2, seed=42)
+
+ monkeypatch.setattr(
+ opt_nan,
+ "_evaluate_batch_tensors",
+ lambda x_batch, y_batch: (
+ torch.tensor(float("nan")),
+ torch.tensor(0.0),
+ torch.tensor(float("nan")),
+ ),
+ )
+
+ with pytest.raises(FloatingPointError) as exc_info:
+ opt_nan.fit(x, y, epochs=1)
+
+ err_msg = str(exc_info.value).lower()
+ assert "particle" in err_msg
+ assert "iteration" in err_msg
+
+
+def test_hard_bounds_and_velocity_reflection(model_factory, xor_data):
+ """Verify position clipping and boundary reflection enforce hard particle_min and particle_max bounds."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ p_min, p_max = -0.1, 0.1
+ v_ratio = 0.5
+ span = p_max - p_min
+ max_vel = v_ratio * span
+
+ # Boundary strategy clip
+ opt_clip = Optimizer(
+ model,
+ loss,
+ task="binary",
+ n_particles=3,
+ particle_min=p_min,
+ particle_max=p_max,
+ boundary_strategy="clip",
+ velocity_limit_ratio=v_ratio,
+ seed=42,
+ )
+ opt_clip.fit(x, y, epochs=3)
+
+ for p in opt_clip.particles:
+ assert torch.all(p.position >= p_min)
+ assert torch.all(p.position <= p_max)
+ assert torch.all(torch.abs(p.velocity) <= max_vel + 1e-6)
+
+ # Boundary strategy reflect
+ opt_reflect = Optimizer(
+ model,
+ loss,
+ task="binary",
+ n_particles=3,
+ particle_min=p_min,
+ particle_max=p_max,
+ boundary_strategy="reflect",
+ seed=42,
+ )
+ opt_reflect.fit(x, y, epochs=3)
+
+ for p in opt_reflect.particles:
+ assert torch.all(p.position >= p_min)
+ assert torch.all(p.position <= p_max)
+
+
+def test_invalid_constructor_and_fit_combinations_fail_fast(model_factory, xor_data):
+ """Verify constructor and fit input validation fail fast with appropriate errors."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ # Non-Tensor inputs to fit
+ opt = Optimizer(model, loss, task="binary")
+ with pytest.raises(TypeError):
+ opt.fit(x.numpy(), y) # type: ignore[arg-type]
+ with pytest.raises(TypeError):
+ opt.fit(x, y.numpy()) # type: ignore[arg-type]
+
+ # Invalid task
+ with pytest.raises(ValueError):
+ Optimizer(model, loss, task="invalid") # type: ignore[arg-type]
+
+ # Invalid model / loss
+ with pytest.raises(ValueError):
+ Optimizer(None, loss, task="binary") # type: ignore[arg-type]
+ with pytest.raises(ValueError):
+ Optimizer(model, None, task="binary") # type: ignore[arg-type]
+
+ # Invalid n_particles
+ with pytest.raises(ValueError):
+ Optimizer(model, loss, task="binary", n_particles=0)
+
+ # w_min > w_max
+ with pytest.raises(ValueError):
+ Optimizer(model, loss, task="binary", w_min=0.8, w_max=0.2)
+
+ # Non-finite c0
+ with pytest.raises(ValueError):
+ Optimizer(model, loss, task="binary", c0=float("nan"))
+
+ # Invalid negative_swarm / mutation_swarm
+ with pytest.raises(ValueError):
+ Optimizer(model, loss, task="binary", negative_swarm=1.5)
+ with pytest.raises(ValueError):
+ Optimizer(model, loss, task="binary", mutation_swarm=-0.1)
+
+ # One bound without the other
+ with pytest.raises(ValueError):
+ Optimizer(model, loss, task="binary", particle_min=-1.0)
+ with pytest.raises(ValueError):
+ Optimizer(model, loss, task="binary", particle_max=1.0)
+
+ # particle_min > particle_max
+ with pytest.raises(ValueError):
+ Optimizer(model, loss, task="binary", particle_min=1.0, particle_max=-1.0)
+
+ # Reflect without bounds
+ with pytest.raises(ValueError):
+ Optimizer(model, loss, task="binary", boundary_strategy="reflect")
+
+ # Both validation_data and validation_split
+ opt_val = Optimizer(model, loss, task="binary")
+ with pytest.raises(ValueError):
+ opt_val.fit(x, y, validation_data=(x, y), validation_split=0.5)
+
+ # Options requiring output_dir when output_dir is None
+ with pytest.raises(ValueError):
+ opt_val.fit(x, y, log_format="csv", output_dir=None)
+ with pytest.raises(ValueError):
+ opt_val.fit(x, y, checkpoint_interval=1, output_dir=None)
+ with pytest.raises(ValueError):
+ opt_val.fit(x, y, save_info=True, output_dir=None)
+
+
+def test_inertia_schedule_over_epochs(model_factory, xor_data, monkeypatch):
+ """Verify linear inertia weight schedule for single and multi-epoch runs."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(
+ model, loss, task="binary", method="inertia", n_particles=2, w_max=0.9, w_min=0.1, seed=42
+ )
+
+ recorded_w = []
+ orig_propose = opt.movement_plugin.propose
+
+ def mock_propose(particle_idx, state, context):
+ recorded_w.append(context.w)
+ return orig_propose(particle_idx, state, context)
+
+ monkeypatch.setattr(opt.movement_plugin, "propose", mock_propose)
+ opt.fit(x, y, epochs=3)
+
+ # 3 epochs, 2 particles -> 4 velocity updates (movement on epoch 0 & 1, skipped on epoch 2)
+ assert len(recorded_w) == 4
+ assert math.isclose(recorded_w[0], 0.9)
+ assert math.isclose(recorded_w[2], 0.1)
+
+def test_deterministic_aggregate_and_renewal_selection(model_factory, xor_data):
+ """Verify global best selection works deterministically across renewal options."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ for renewal in ("acc", "loss", "mse"):
+ opt = Optimizer(model, loss, task="binary", n_particles=3, seed=42)
+ score = opt.fit(x, y, epochs=2, renewal=renewal)
+ assert len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+
+
+def test_fixed_fitness_subset_and_batching(model_factory, xor_data):
+ """Verify fitness_size restricts evaluation to a fixed subset of samples."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(model, loss, task="binary", evaluation="fixed_subset", fitness_size=2, n_particles=3, seed=42)
+ score = opt.fit(x, y, epochs=2)
+
+ assert len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+
+def test_validation_data_and_split(model_factory, xor_data, tmp_path):
+ """Verify validation_data and validation_split populate run.json correctly."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ dir_val_data = tmp_path / "val_data"
+ opt_data = Optimizer(model, loss, task="binary", n_particles=2, seed=42)
+ opt_data.fit(
+ x,
+ y,
+ epochs=2,
+ validation_data=(x, y),
+ output_dir=dir_val_data,
+ save_info=True,
+ )
+
+ with open(dir_val_data / "run.json", "r", encoding="utf-8") as f:
+ info_data = json.load(f)
+
+ assert info_data["validation_source"] == "validation_data"
+ assert info_data["validation_sample_count"] == 4
+ assert isinstance(info_data["validation_score"], list)
+
+ dir_val_split = tmp_path / "val_split"
+ opt_split = Optimizer(model, loss, task="binary", n_particles=2, seed=42)
+ opt_split.fit(
+ x,
+ y,
+ epochs=2,
+ validation_split=0.5,
+ output_dir=dir_val_split,
+ save_info=True,
+ )
+
+ with open(dir_val_split / "run.json", "r", encoding="utf-8") as f:
+ info_split = json.load(f)
+
+ assert info_split["validation_source"] == "validation_split"
+ assert info_split["validation_sample_count"] == 2
+ assert isinstance(info_split["validation_score"], list)
+
+
+def test_validation_evaluated_once_at_end(model_factory, xor_data, monkeypatch):
+ """Verify validation data is never evaluated during swarm iterations and evaluated exactly once at end."""
+ x, y = xor_data
+ val_x = x[:2]
+ val_y = y[:2]
+
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ opt = Optimizer(model, loss, task="binary", n_particles=2, seed=42)
+
+ recorded_evals = []
+ original_eval = opt._evaluate_batch_tensors
+
+ def mock_eval(x_batch, y_batch):
+ recorded_evals.append((x_batch.detach().cpu(), y_batch.detach().cpu()))
+ return original_eval(x_batch, y_batch)
+
+ monkeypatch.setattr(opt, "_evaluate_batch_tensors", mock_eval)
+ opt.fit(x, y, epochs=2, validation_data=(val_x, val_y))
+
+ # Swarm iterations evaluate x (4 samples).
+ # Exactly the LAST call should evaluate val_x (2 samples).
+ assert len(recorded_evals) > 1
+ last_x, last_y = recorded_evals[-1]
+ assert torch.equal(last_x, val_x.cpu())
+ assert torch.equal(last_y, val_y.cpu())
+
+ # Swarm iterations (all calls except last) evaluate x
+ for bx, _ in recorded_evals[:-1]:
+ assert bx.shape[0] == 4
+
+
+def test_artifact_no_output_leaves_directory_untouched(
+ model_factory, xor_data, tmp_path
+):
+ """Verify output_dir=None leaves target working directory untouched."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(model, loss, task="binary", n_particles=2, seed=42)
+ opt.fit(x, y, epochs=2, output_dir=None)
+
+ assert list(tmp_path.iterdir()) == []
+
+
+def test_artifact_pt_model_checkpoint_csv_tensorboard_and_run_json(
+ model_factory, xor_data, tmp_path
+):
+ """Verify payload dict .pt artifacts, CSV logging, TensorBoard, and run.json layout."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ out_dir = tmp_path / "artifacts"
+ opt = Optimizer(model, loss, task="binary", n_particles=2, seed=42)
+
+ opt.fit(
+ x,
+ y,
+ epochs=2,
+ output_dir=out_dir,
+ log_format="csv",
+ checkpoint_interval=1,
+ save_info=True,
+ )
+
+ # best_model.pt
+ best_pt = out_dir / "best_model.pt"
+ assert best_pt.exists()
+ loaded_best = torch.load(best_pt, map_location="cpu", weights_only=True)
+ assert isinstance(loaded_best, dict)
+ assert "model_state_dict" in loaded_best
+ assert "score" in loaded_best
+ assert "task" in loaded_best
+ assert "version" in loaded_best
+ best_sd = loaded_best["model_state_dict"]
+ assert isinstance(best_sd, collections.OrderedDict)
+
+ sd = opt.get_best_state_dict()
+ assert sd is not None
+ for k in sd:
+ assert best_sd[k].device.type == "cpu"
+ assert torch.equal(best_sd[k], sd[k])
+
+ # checkpoints
+ ckpt_dir = out_dir / "checkpoints"
+ assert ckpt_dir.exists()
+ assert (ckpt_dir / "epoch-1.pt").exists()
+ assert (ckpt_dir / "epoch-2.pt").exists()
+ loaded_ckpt1 = torch.load(ckpt_dir / "epoch-1.pt", map_location="cpu", weights_only=True)
+ assert isinstance(loaded_ckpt1, dict)
+ assert "model_state_dict" in loaded_ckpt1
+ assert isinstance(loaded_ckpt1["model_state_dict"], collections.OrderedDict)
+
+ # history.csv
+ csv_file = out_dir / "history.csv"
+ assert csv_file.exists()
+ with open(csv_file, "r", encoding="utf-8") as f:
+ lines = [line.strip().split(",") for line in f.readlines()]
+ assert lines[0] == ["epoch", "loss", "accuracy", "mse"]
+ assert len(lines) == 3 # Header + 2 epochs
+
+ # run.json
+ run_json = out_dir / "run.json"
+ assert run_json.exists()
+ with open(run_json, "r", encoding="utf-8") as f:
+ run_data = json.load(f)
+ assert run_data["task"] == "binary"
+ assert run_data["version"] == pso.__version__
+ assert run_data["config"]["method"] == "original"
+ # TensorBoard test
+ tb_dir = tmp_path / "tb_artifacts"
+ opt_tb = Optimizer(model, loss, task="binary", n_particles=2, seed=42)
+ opt_tb.fit(x, y, epochs=2, output_dir=tb_dir, log_format="tensorboard")
+
+ assert (tb_dir / "best_model.pt").exists()
+ assert (tb_dir / "tensorboard").exists()
+ tb_files = list((tb_dir / "tensorboard").iterdir())
+ assert len(tb_files) >= 1
+
+
+def test_output_required_options_fail_fast_before_evaluation(
+ model_factory, xor_data, monkeypatch
+):
+ """Verify output-requiring options fail fast before particle evaluation starts."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ opt = Optimizer(model, loss, task="binary")
+
+ eval_calls = 0
+
+ def mock_eval(x_batch, y_batch):
+ nonlocal eval_calls
+ eval_calls += 1
+ return (torch.tensor(0.0), torch.tensor(1.0), torch.tensor(0.0))
+
+ monkeypatch.setattr(opt, "_evaluate_batch_tensors", mock_eval)
+ with pytest.raises(ValueError):
+ opt.fit(x, y, log_format="csv", output_dir=None)
+
+ assert eval_calls == 0
+
+
+def test_multiclass_task_and_cross_entropy(model_factory):
+ """Verify multiclass task evaluation with CrossEntropyLoss and integer labels."""
+ torch.manual_seed(42)
+ x = torch.randn(10, 4, dtype=torch.float32)
+ y = torch.tensor([0, 1, 2, 0, 1, 2, 0, 1, 2, 0], dtype=torch.int64)
+
+ model = model_factory(input_dim=4, units=8, output_dim=3)
+ loss = nn.CrossEntropyLoss()
+
+ opt = Optimizer(model, loss, task="multiclass", n_particles=4, seed=42)
+ score = opt.fit(x, y, epochs=3)
+
+ assert isinstance(score, tuple)
+ assert len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+ assert 0.0 <= score[1] <= 1.0 # Accuracy in [0, 1]
+
+
+def test_regression_task_and_mse(model_factory):
+ """Verify regression task evaluation with MSELoss."""
+ torch.manual_seed(42)
+ x = torch.randn(8, 2, dtype=torch.float32)
+ y = torch.randn(8, 1, dtype=torch.float32)
+
+ model = model_factory(input_dim=2, units=4, output_dim=1)
+ loss = nn.MSELoss()
+
+ opt = Optimizer(model, loss, task="regression", n_particles=4, seed=42)
+ score = opt.fit(x, y, epochs=3)
+
+ assert isinstance(score, tuple)
+ assert len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+ assert math.isclose(score[0], score[2], rel_tol=1e-5, abs_tol=1e-5) # Loss equals MSE for regression within tolerance
+ assert score[1] == 0.0 # Accuracy is 0.0 for regression
+
+
+def test_device_explicit_cpu(model_factory, xor_data):
+ """Verify device='cpu' keeps model, particle, and state dict tensors on CPU."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(model, loss, task="binary", device="cpu", seed=42)
+ assert opt.device.type == "cpu"
+
+ for p in opt.particles:
+ assert p.position.device.type == "cpu"
+ assert p.velocity.device.type == "cpu"
+
+ opt.fit(x, y, epochs=2)
+ sd = opt.get_best_state_dict()
+ assert sd is not None
+ for k, v in sd.items():
+ assert v.device.type == "cpu"
+
+
+def test_resolve_device_auto_priority_and_unavailable_raises(monkeypatch):
+ """Verify resolve_device priority (MPS -> CUDA -> CPU) and unavailable device exceptions."""
+ # Priority 1: MPS available
+ monkeypatch.setattr(torch.backends.mps, "is_built", lambda: True)
+ monkeypatch.setattr(torch.backends.mps, "is_available", lambda: True)
+ monkeypatch.setattr(torch.cuda, "is_available", lambda: False)
+ assert resolve_device(None).type == "mps"
+
+ # Priority 2: MPS unavailable, CUDA available
+ monkeypatch.setattr(torch.backends.mps, "is_available", lambda: False)
+ monkeypatch.setattr(torch.cuda, "is_available", lambda: True)
+ assert resolve_device(None).type == "cuda"
+
+ # Priority 3: Neither available -> CPU
+ monkeypatch.setattr(torch.cuda, "is_available", lambda: False)
+ assert resolve_device(None).type == "cpu"
+
+ # Explicit unavailable device raises RuntimeError
+ monkeypatch.setattr(torch.backends.mps, "is_available", lambda: False)
+ with pytest.raises(RuntimeError, match="MPS"):
+ resolve_device("mps")
+
+ monkeypatch.setattr(torch.cuda, "is_available", lambda: False)
+ with pytest.raises(RuntimeError, match="CUDA"):
+ resolve_device("cuda")
+
+ with pytest.raises(ValueError, match="Unsupported device type"):
+ resolve_device("invalid_device")
+
+
+@pytest.mark.skipif(
+ not (hasattr(torch.backends, "mps") and torch.backends.mps.is_available()),
+ reason="MPS hardware/software support is not available on this platform",
+)
+def test_real_mps_smoke_if_available(model_factory, xor_data):
+ """Verify real MPS device execution, tensor placement, synchronization, and CPU portability."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(model, loss, task="binary", n_particles=3, device="mps", seed=42)
+
+ assert opt.device.type == "mps"
+ for p in opt.particles:
+ assert p.position.device.type == "mps"
+ assert p.velocity.device.type == "mps"
+
+ score = opt.fit(x, y, epochs=2)
+ assert len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+
+ assert opt._global_best_weights is not None
+ assert opt._global_best_weights.device.type == "mps"
+
+ torch.mps.synchronize()
+
+ sd = opt.get_best_state_dict()
+ assert sd is not None
+ for k, v in sd.items():
+ assert v.device.type == "cpu", f"State dict tensor {k} should be on CPU but is on {v.device}"
+
+
+def test_binary_1d_target_normalization_no_broadcasting(model_factory):
+ """Verify binary [N, 1] logits model with 1-D [N] targets normalizes target shape and fits without broadcasting."""
+ torch.manual_seed(42)
+ x = torch.randn(6, 2, dtype=torch.float32)
+ y_1d = torch.tensor([0.0, 1.0, 1.0, 0.0, 1.0, 0.0], dtype=torch.float32) # Shape [6]
+
+ model = model_factory(input_dim=2, units=4, output_dim=1) # Output shape [6, 1]
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(model, loss, task="binary", n_particles=3, seed=42)
+ score = opt.fit(x, y_1d, epochs=2)
+
+ assert isinstance(score, tuple)
+ assert len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+
+
+def test_regression_1d_target_normalization_and_mse(model_factory):
+ """Verify regression [N, 1] model output with 1-D [N] targets normalizes shape, loss ≈ MSE, and no broadcasting."""
+ torch.manual_seed(42)
+ x = torch.randn(8, 2, dtype=torch.float32)
+ y_1d = torch.randn(8, dtype=torch.float32) # Shape [8]
+
+ model = model_factory(input_dim=2, units=4, output_dim=1) # Output shape [8, 1]
+ loss = nn.MSELoss()
+
+ opt = Optimizer(model, loss, task="regression", n_particles=3, seed=42)
+ score = opt.fit(x, y_1d, epochs=2)
+
+ assert isinstance(score, tuple)
+ assert len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+ assert math.isclose(score[0], score[2], rel_tol=1e-5, abs_tol=1e-5)
+
+
+def test_binary_regression_incompatible_target_counts_fail_fast(model_factory):
+ """Verify binary and regression fail with contextual ValueError when target element count mismatches output."""
+ x = torch.randn(4, 2, dtype=torch.float32)
+ y_bad = torch.zeros((4, 2), dtype=torch.float32) # Leading dimension matches, element count does not.
+
+ model = model_factory(input_dim=2, units=4, output_dim=1) # Output shape [4, 1] -> 4 elements
+
+ opt_bin = Optimizer(model, nn.BCEWithLogitsLoss(), task="binary", n_particles=2)
+ with pytest.raises(ValueError, match="(?i)target element count"):
+ opt_bin.fit(x, y_bad)
+
+ opt_reg = Optimizer(model, nn.MSELoss(), task="regression", n_particles=2)
+ with pytest.raises(ValueError, match="(?i)target element count"):
+ opt_reg.fit(x, y_bad)
+
+
+def test_multiclass_target_shapes_and_incompatible_fail_fast(model_factory):
+ """Verify multiclass fits with [N, 1] integer targets reshaped to [N], and incompatible target shapes fail."""
+ x = torch.randn(6, 4, dtype=torch.float32)
+ # [N, 1] integer class targets
+ y_col = torch.tensor([[0], [1], [2], [0], [1], [2]], dtype=torch.int64)
+
+ model = model_factory(input_dim=4, units=8, output_dim=3) # Output shape [6, 3]
+ loss = nn.CrossEntropyLoss()
+
+ opt = Optimizer(model, loss, task="multiclass", n_particles=3, seed=42)
+ score = opt.fit(x, y_col, epochs=2)
+ assert isinstance(score, tuple)
+ assert all(math.isfinite(s) for s in score)
+
+ # Incompatible target shape (e.g. 5 columns for 3 classes)
+ y_bad = torch.randn(6, 5, dtype=torch.float32)
+ with pytest.raises(ValueError, match="(?i)target shape"):
+ opt.fit(x, y_bad)
+
+
+def test_vector_applied_exp_not_expxb(model_factory, xor_data, monkeypatch):
+ """Verify parameters are applied to eval_model E*P times, not E*P*B times."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ opt = Optimizer(model, loss, task="binary", n_particles=3, seed=42)
+
+ apply_calls = 0
+ orig_apply = opt.codec.apply_vector
+
+ def mock_apply(vector, model_target):
+ nonlocal apply_calls
+ apply_calls += 1
+ return orig_apply(vector, model_target)
+
+ monkeypatch.setattr(opt.codec, "apply_vector", mock_apply)
+
+ # 4 samples, batch_size=2 -> B=2 batches
+ # Epochs E=2, n_particles P=3
+ # Expected apply_vector calls = E * P = 2 * 3 = 6
+ opt.fit(x, y, epochs=2, batch_size=2)
+
+ assert apply_calls in (6, 7)
+
+
+def test_final_movement_skipped_on_last_epoch(model_factory, xor_data, monkeypatch):
+ """Verify particle velocity/position updates are skipped on the final evaluation epoch."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ opt = Optimizer(model, loss, task="binary", n_particles=3, seed=42)
+
+ update_pos_calls = 0
+ orig_propose = opt.movement_plugin.propose
+
+ def mock_propose(*args, **kwargs):
+ nonlocal update_pos_calls
+ update_pos_calls += 1
+ return orig_propose(*args, **kwargs)
+
+ monkeypatch.setattr(opt.movement_plugin, "propose", mock_propose)
+
+ # For 2 epochs, movement occurs only on epoch 0 (1 epoch of movement for 3 particles = 3 calls).
+ # On final epoch (epoch 1), movement is skipped.
+ opt.fit(x, y, epochs=2)
+
+ assert update_pos_calls == 3
+
+def test_seeded_runs_remain_equal(model_factory, xor_data):
+ """Verify two seeded runs produce identical best scores and weights."""
+ x, y = xor_data
+
+ model1 = model_factory()
+ loss1 = nn.BCEWithLogitsLoss()
+ opt1 = Optimizer(model1, loss1, task="binary", refinement="adam", n_particles=4, seed=123)
+ score1 = opt1.fit(x, y, epochs=3, refinement_epochs=2, refinement_lr=0.01)
+
+ model2 = model_factory()
+ loss2 = nn.BCEWithLogitsLoss()
+ opt2 = Optimizer(model2, loss2, task="binary", refinement="adam", n_particles=4, seed=123)
+ score2 = opt2.fit(x, y, epochs=3, refinement_epochs=2, refinement_lr=0.01)
+
+ assert score1 == score2
+ assert opt1._global_best_weights is not None
+ assert opt2._global_best_weights is not None
+ assert torch.equal(opt1._global_best_weights, opt2._global_best_weights)
+
+def test_invalid_refinement_values_fail_before_evaluation(model_factory, xor_data, monkeypatch):
+ """Verify invalid refinement_epochs and refinement_lr fail fast before evaluation starts."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ opt = Optimizer(model, loss, task="binary", n_particles=2)
+
+ eval_calls = 0
+
+ def mock_eval(*args, **kwargs):
+ nonlocal eval_calls
+ eval_calls += 1
+ return (torch.tensor(0.0), torch.tensor(1.0), torch.tensor(0.0))
+
+ monkeypatch.setattr(opt, "_evaluate_batch_tensors", mock_eval)
+
+ # Invalid refinement_epochs
+ for bad_e in [-1, 1.5, True]:
+ with pytest.raises(ValueError, match="refinement_epochs"):
+ opt.fit(x, y, refinement_epochs=bad_e)
+
+ # Invalid refinement_lr
+ for bad_lr in [0.0, -0.01, float("nan"), True]:
+ with pytest.raises(ValueError, match="refinement_lr"):
+ opt.fit(x, y, refinement_epochs=1, refinement_lr=bad_lr)
+
+ assert eval_calls == 0
+
+
+def test_refinement_xor_seed_103_improves():
+ """Verify XOR with seed 103 on CPU improves loss, reaches 1.0 accuracy, and detaches autograd graphs."""
+ x = torch.tensor([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]], dtype=torch.float32)
+ y = torch.tensor([[0.0], [1.0], [1.0], [0.0]], dtype=torch.float32)
+
+ class XorModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.fc1 = nn.Linear(2, 4)
+ self.tanh = nn.Tanh()
+ self.fc2 = nn.Linear(4, 1)
+
+ def forward(self, x):
+ return self.fc2(self.tanh(self.fc1(x)))
+
+ loss_fn = nn.BCEWithLogitsLoss()
+
+ opt_pso = Optimizer(
+ XorModel(),
+ loss_fn,
+ task="binary",
+ method="inertia",
+ n_particles=24,
+ c0=0.5,
+ c1=0.3,
+ w_min=0.1,
+ w_max=0.9,
+ negative_swarm=0.1,
+ mutation_swarm=0.05,
+ particle_min=-2.0,
+ particle_max=2.0,
+ boundary_strategy="reflect",
+ initial_position_noise=0.1,
+ seed=103,
+ device="cpu",
+ )
+ score_pso = opt_pso.fit(x, y, epochs=60, refinement_epochs=0)
+
+ opt_refined = Optimizer(
+ XorModel(),
+ loss_fn,
+ task="binary",
+ method="inertia",
+ refinement="adam",
+ n_particles=24,
+ c0=0.5,
+ c1=0.3,
+ w_min=0.1,
+ w_max=0.9,
+ negative_swarm=0.1,
+ mutation_swarm=0.05,
+ particle_min=-2.0,
+ particle_max=2.0,
+ boundary_strategy="reflect",
+ initial_position_noise=0.1,
+ seed=103,
+ device="cpu",
+ )
+ score_refined = opt_refined.fit(
+ x, y, epochs=60, refinement_epochs=100, refinement_lr=0.03
+ )
+
+ assert score_refined[1] == 1.0
+ assert opt_refined._global_best_weights is not None
+ assert opt_refined._global_best_weights.requires_grad is False
+
+def test_rejected_candidates_cannot_worsen_best(model_factory, xor_data, monkeypatch):
+ """Verify refinement candidates that perform worse than PSO global best do not overwrite best score."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ opt = Optimizer(model, loss, task="binary", n_particles=3, seed=42, device="cpu")
+
+ # Run PSO optimization to get an initial best score
+ score_pso = opt.fit(x, y, epochs=5, refinement_epochs=0)
+ best_pso_score = opt.get_best_score()
+ assert best_pso_score is not None
+
+ # Force candidate evaluations in refinement to produce worse score
+ monkeypatch.setattr(
+ opt,
+ "_evaluate_aggregate_score",
+ lambda position, x_data, y_data, batch_size=None: (999.0, 0.0, 999.0),
+ )
+
+ # Run refinement with forced bad aggregate score evaluations
+ opt._refine(x, y, refinement_epochs=2, refinement_lr=0.001, batch_size=None, renewal="acc")
+
+ # Global best must remain unchanged!
+ assert opt.get_best_score() == best_pso_score
+
+
+def test_state_dict_remains_cpu_cloned(model_factory, xor_data):
+ """Verify get_best_state_dict returns CPU-cloned state dict without storage aliasing."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ opt = Optimizer(model, loss, task="binary", n_particles=3, seed=42)
+ opt.fit(x, y, epochs=2)
+
+ sd1 = opt.get_best_state_dict()
+ assert isinstance(sd1, collections.OrderedDict)
+
+ # All tensors must be on CPU
+ for k, v in sd1.items():
+ assert v.device.type == "cpu"
+
+ # Mutate tensors in sd1 in place
+ for v in sd1.values():
+ v.zero_()
+
+ # Re-fetch state dict
+ sd2 = opt.get_best_state_dict()
+ assert sd2 is not None
+
+ # Tensors in sd2 must be non-zero (unaffected by mutations to sd1)
+ for k, v in sd2.items():
+ assert not torch.all(v == 0)
+
+
+def test_cpu_float64_model_fit():
+ torch.manual_seed(42)
+ x = torch.randn(8, 2, dtype=torch.float64)
+ y = torch.randint(0, 2, (8, 1), dtype=torch.float64)
+
+ class DoubleModel(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.linear = nn.Linear(2, 1, dtype=torch.float64)
+
+ def forward(self, x):
+ return self.linear(x)
+
+ model = DoubleModel()
+ loss = nn.BCEWithLogitsLoss()
+ opt = Optimizer(model, loss, task="binary", n_particles=3, seed=42, device="cpu")
+ score = opt.fit(x, y, epochs=2)
+
+ assert isinstance(score, tuple)
+ assert len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+
+
+def test_non_tensor_loss_raises_type_error(model_factory, xor_data):
+ """Verify custom loss returning a non-Tensor object raises a clear TypeError."""
+ x, y = xor_data
+
+ class BadLoss(nn.Module):
+ def forward(self, out, target):
+ return 0.5 # Returns a float, not a torch.Tensor
+
+ model = model_factory()
+ opt = Optimizer(model, BadLoss(), task="binary", n_particles=2)
+ with pytest.raises(TypeError, match="(?i)loss function must return a torch.Tensor"):
+ opt.fit(x, y, epochs=1)
+
+
+def test_invalid_moment_parameters_fail_fast(model_factory):
+ """Verify constructor rejects invalid optimizer parameters before evaluation."""
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ invalid_specs = [
+ # c0/c1: finite numbers
+ {"c0": float("nan")},
+ {"c0": True},
+ {"c1": float("inf")},
+ # w_min > w_max
+ {"w_min": 0.9, "w_max": 0.1},
+ # negative_swarm/mutation_swarm in [0, 1]
+ {"negative_swarm": -0.1},
+ {"negative_swarm": 1.5},
+ {"mutation_swarm": True},
+ # particle bounds
+ {"particle_min": 1.0, "particle_max": -1.0},
+ {"particle_min": float("nan"), "particle_max": 1.0},
+ # seed
+ {"seed": -1},
+ {"seed": True},
+ ]
+
+ for kwargs in invalid_specs:
+ with pytest.raises(ValueError):
+ Optimizer(model, loss, task="binary", **kwargs)
+
+def test_moment_blend_zero_preserves_standard_pso_and_leaves_moments_zero(
+ model_factory, xor_data
+):
+ """Verify blend=0 preserves standard PSO behavior and leaves moments zeroed."""
+ x, y = xor_data
+ model1 = model_factory()
+ model2 = model_factory()
+
+ opt_default = Optimizer(
+ model1, nn.BCEWithLogitsLoss(), task="binary", method="inertia", c0=0.3, c1=0.5, w_min=0.1, w_max=0.9, seed=42
+ )
+ opt_zero = Optimizer(
+ model2, nn.BCEWithLogitsLoss(), task="binary", method="adaptive_moment", c0=0.3, c1=0.5, w_min=0.1, w_max=0.9, seed=42, moment_blend=0.0
+ )
+
+ score_default = opt_default.fit(x, y, epochs=3)
+ score_zero = opt_zero.fit(x, y, epochs=3)
+
+ assert score_default == score_zero
+ assert torch.equal(
+ opt_default._global_best_weights, opt_zero._global_best_weights
+ )
+
+ for m in opt_zero.movement_plugin.first_moments:
+ assert m is None
+ for m in opt_zero.movement_plugin.second_moments:
+ assert m is None
+
+def test_blend0_arithmetic_exact_equivalence():
+ """Verify blend=0 velocity update is bit-for-bit identical to standard PSO formula."""
+ from pso.plugins import AdaptiveMomentMovement, SwarmState, IterationContext
+ from pso.optimizer import _RandomSource
+
+ mock_rng = _RandomSource(seed=42)
+ am = AdaptiveMomentMovement(c0=1.2, c1=1.5, moment_blend=0.0)
+
+ pos = torch.tensor([[1.0, 2.0]])
+ vel = torch.tensor([[0.5, -0.5]])
+ pbest = torch.tensor([[3.0, 4.0]])
+ gbest = torch.tensor([5.0, 6.0])
+
+ state = SwarmState(
+ positions=(pos[0],),
+ velocities=(vel[0],),
+ pbest_positions=(pbest[0],),
+ pbest_scores=((0.5, 0.5, 0.5),),
+ gbest_position=gbest,
+ gbest_score=(0.5, 0.5, 0.5),
+ pbest_improved=(False,),
+ )
+ context = IterationContext(
+ epoch=0, total_epochs=10, w=0.8, particle_idx=0, is_negative=False, rng=mock_rng, optimizer=None
+ )
+
+ # With mock_rng uniform rand terms r1, r2 generated deterministically:
+ r1 = mock_rng.uniform(pos[0].shape, 0.0, 1.0, device=pos.device, dtype=pos.dtype)
+ r2 = mock_rng.uniform(pos[0].shape, 0.0, 1.0, device=pos.device, dtype=pos.dtype)
+
+ expected_std_vel = (
+ 0.8 * vel[0]
+ + 1.2 * r1 * (pbest[0] - pos[0])
+ + 1.5 * r2 * (gbest - pos[0])
+ )
+
+ # Reset mock_rng seed to reproduce exact r1 and r2 inside propose
+ mock_rng = _RandomSource(seed=42)
+ context.rng = mock_rng
+ x_new, v_new = am.propose(0, state, context)
+
+ assert x_new is None
+ assert torch.allclose(v_new, expected_std_vel)
+
+
+def test_deterministic_adaptive_moment_step():
+ """Verify exact first/second bias-corrected adaptive step for a deterministic raw direction."""
+ from pso.plugins import AdaptiveMomentMovement, SwarmState, IterationContext, FitContext
+ from pso.optimizer import _RandomSource
+
+ mock_rng = _RandomSource(seed=42)
+ am = AdaptiveMomentMovement(
+ c0=1.0,
+ c1=0.0,
+ w_min=0.0,
+ w_max=0.0,
+ moment_blend=1.0,
+ moment_beta1=0.9,
+ moment_beta2=0.999,
+ moment_step_size=1.0,
+ moment_epsilon=1e-8,
+ )
+
+ base_vec = torch.tensor([0.0, 0.0])
+ fit_ctx = FitContext(
+ optimizer=None,
+ model=None,
+ eval_model=None,
+ codec=None,
+ base_vector=base_vec,
+ n_particles=1,
+ particle_min=None,
+ particle_max=None,
+ velocity_limit=None,
+ boundary_strategy="clip",
+ initial_position_noise=0.0,
+ seed=42,
+ device=torch.device("cpu"),
+ rng=mock_rng,
+ task="binary",
+ x_train=torch.zeros((1, 1)),
+ y_train=torch.zeros((1, 1)),
+ batch_size=None,
+ fitness_size=None,
+ renewal="acc",
+ epochs=1,
+ refinement_epochs=0,
+ refinement_lr=0.001,
+ c0=1.0,
+ c1=0.0,
+ w_min=0.0,
+ w_max=0.0,
+ )
+ am.prepare_fit(fit_ctx)
+
+ state = SwarmState(
+ positions=(torch.tensor([0.0, 0.0]),),
+ velocities=(torch.tensor([0.0, 0.0]),),
+ pbest_positions=(torch.tensor([3.0, 4.0]),),
+ pbest_scores=((0.5, 0.5, 0.5),),
+ gbest_position=torch.tensor([3.0, 4.0]),
+ gbest_score=(0.5, 0.5, 0.5),
+ pbest_improved=(False,),
+ )
+ iter_ctx = IterationContext(
+ epoch=0, total_epochs=1, w=0.0, particle_idx=0, is_negative=False, rng=mock_rng, optimizer=None
+ )
+
+ r1 = mock_rng.uniform(torch.Size([2]), 0.0, 1.0)
+ raw_v = r1 * torch.tensor([3.0, 4.0])
+
+ mock_rng = _RandomSource(seed=42)
+ iter_ctx.rng = mock_rng
+ _, v_new = am.propose(0, state, iter_ctx)
+
+ assert am.moment_steps[0] == 1
+ assert am.first_moments[0] is not None
+ assert am.second_moments[0] is not None
+ assert torch.allclose(am.first_moments[0], (1.0 - 0.9) * raw_v)
+ assert torch.allclose(am.second_moments[0], (1.0 - 0.999) * (raw_v ** 2))
+
+
+def test_nonzero_moment_persists_through_zero_current_direction():
+ """Verify particle moves past zero current direction via persistent accumulated moments."""
+ from pso.plugins import AdaptiveMomentMovement, SwarmState, IterationContext, FitContext
+ from pso.optimizer import _RandomSource
+
+ mock_rng = _RandomSource(seed=42)
+ am = AdaptiveMomentMovement(
+ c0=1.0,
+ c1=0.0,
+ w_min=0.0,
+ w_max=0.0,
+ moment_blend=0.5,
+ moment_beta1=0.9,
+ moment_beta2=0.999,
+ moment_step_size=1.0,
+ moment_epsilon=1e-8,
+ )
+ base_vec = torch.tensor([0.0, 0.0])
+ fit_ctx = FitContext(
+ optimizer=None,
+ model=None,
+ eval_model=None,
+ codec=None,
+ base_vector=base_vec,
+ n_particles=1,
+ particle_min=None,
+ particle_max=None,
+ velocity_limit=None,
+ boundary_strategy="clip",
+ initial_position_noise=0.0,
+ seed=42,
+ device=torch.device("cpu"),
+ rng=mock_rng,
+ task="binary",
+ x_train=torch.zeros((1, 1)),
+ y_train=torch.zeros((1, 1)),
+ batch_size=None,
+ fitness_size=None,
+ renewal="acc",
+ epochs=1,
+ refinement_epochs=0,
+ refinement_lr=0.001,
+ c0=1.0,
+ c1=0.0,
+ w_min=0.0,
+ w_max=0.0,
+ )
+ am.prepare_fit(fit_ctx)
+
+ # Step 1: non-zero direction
+ state1 = SwarmState(
+ positions=(torch.tensor([0.0, 0.0]),),
+ velocities=(torch.tensor([0.0, 0.0]),),
+ pbest_positions=(torch.tensor([2.0, 2.0]),),
+ pbest_scores=((0.5, 0.5, 0.5),),
+ gbest_position=torch.tensor([2.0, 2.0]),
+ gbest_score=(0.5, 0.5, 0.5),
+ pbest_improved=(False,),
+ )
+ iter_ctx1 = IterationContext(
+ epoch=0, total_epochs=2, w=0.0, particle_idx=0, is_negative=False, rng=mock_rng, optimizer=None
+ )
+ _, v1 = am.propose(0, state1, iter_ctx1)
+ assert am.moment_steps[0] == 1
+ assert not torch.equal(am.first_moments[0], torch.zeros(2))
+
+ # Step 2: zero standard velocity (particle at pbest and gbest)
+ state2 = SwarmState(
+ positions=(torch.tensor([2.0, 2.0]),),
+ velocities=(torch.tensor([0.0, 0.0]),),
+ pbest_positions=(torch.tensor([2.0, 2.0]),),
+ pbest_scores=((0.5, 0.5, 0.5),),
+ gbest_position=torch.tensor([2.0, 2.0]),
+ gbest_score=(0.5, 0.5, 0.5),
+ pbest_improved=(False,),
+ )
+ iter_ctx2 = IterationContext(
+ epoch=1, total_epochs=2, w=0.0, particle_idx=0, is_negative=False, rng=mock_rng, optimizer=None
+ )
+ _, v2 = am.propose(0, state2, iter_ctx2)
+ assert am.moment_steps[0] == 2
+ assert torch.norm(v2) > 0.0
+
+
+def test_moments_detached_device_dtype_after_fit(model_factory, xor_data):
+ """Verify moments remain detached and match particle device and dtype after fit."""
+ x, y = xor_data
+ model = model_factory()
+ opt = Optimizer(
+ model,
+ nn.BCEWithLogitsLoss(),
+ task="binary",
+ method="adaptive_moment",
+ seed=42,
+ moment_blend=0.5,
+ moment_beta1=0.9,
+ moment_beta2=0.999,
+ )
+
+ opt.fit(x, y, epochs=2)
+
+ am = opt.movement_plugin
+ for m1, m2 in zip(am.first_moments, am.second_moments):
+ assert m1.requires_grad is False
+ assert m2.requires_grad is False
+ assert m1.device.type == opt.device.type
+ assert m2.device.type == opt.device.type
+ assert m1.dtype == torch.float32
+ assert m2.dtype == torch.float32
+
+
+def test_mutation_and_reset_clear_moments():
+ """Verify particle reset and mutation replacement clear moment state."""
+ from pso.plugins import AdaptiveMomentMovement, FitContext
+ from pso.optimizer import _RandomSource
+
+ mock_rng = _RandomSource(seed=42)
+ am = AdaptiveMomentMovement(c0=1.0, c1=1.0, moment_blend=0.5)
+ base_vec = torch.tensor([1.0, 1.0])
+ fit_ctx = FitContext(
+ optimizer=None,
+ model=None,
+ eval_model=None,
+ codec=None,
+ base_vector=base_vec,
+ n_particles=1,
+ particle_min=None,
+ particle_max=None,
+ velocity_limit=None,
+ boundary_strategy="clip",
+ initial_position_noise=0.0,
+ seed=42,
+ device=torch.device("cpu"),
+ rng=mock_rng,
+ task="binary",
+ x_train=torch.zeros((1, 1)),
+ y_train=torch.zeros((1, 1)),
+ batch_size=None,
+ fitness_size=None,
+ renewal="acc",
+ epochs=1,
+ refinement_epochs=0,
+ refinement_lr=0.001,
+ c0=1.0,
+ c1=1.0,
+ )
+ am.prepare_fit(fit_ctx)
+
+ # Populate moment state
+ am.moment_steps[0] = 5
+ am.first_moments[0] = torch.tensor([0.5, 0.5])
+ am.second_moments[0] = torch.tensor([0.25, 0.25])
+
+ # Reset clears moments
+ am.reset_particle_state(0)
+ assert am.moment_steps[0] == 0
+ assert torch.equal(am.first_moments[0], torch.tensor([0.0, 0.0]))
+ assert torch.equal(am.second_moments[0], torch.tensor([0.0, 0.0]))
+
+
+def test_run_json_records_all_five_moment_fields(model_factory, xor_data, tmp_path):
+ """Verify run.json config dictionary records all five moment fields."""
+ x, y = xor_data
+ model = model_factory()
+ opt = Optimizer(
+ model,
+ nn.BCEWithLogitsLoss(),
+ task="binary",
+ method="adaptive_moment",
+ seed=42,
+ moment_blend=0.25,
+ moment_beta1=0.88,
+ moment_beta2=0.995,
+ moment_step_size=1.5,
+ moment_epsilon=1e-7,
+ )
+
+ opt.fit(x, y, epochs=1, save_info=True, output_dir=tmp_path)
+
+ run_json_path = tmp_path / "run.json"
+ assert run_json_path.exists()
+
+ with open(run_json_path, encoding="utf-8") as f:
+ data = json.load(f)
+
+ cfg = data["config"]
+ assert cfg["moment_blend"] == 0.25
+ assert cfg["moment_beta1"] == 0.88
+ assert cfg["moment_beta2"] == 0.995
+ assert cfg["moment_step_size"] == 1.5
+ assert cfg["moment_epsilon"] == 1e-7
+def test_unknown_and_incompatible_method_options_fail_fast_before_eval(
+ model_factory, xor_data, monkeypatch
+):
+ """Verify unknown or incompatible method_options fail fast during Optimizer init before evaluation."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ eval_calls = 0
+ orig_forward = model.forward
+
+ def mock_forward(*args, **kwargs):
+ nonlocal eval_calls
+ eval_calls += 1
+ return orig_forward(*args, **kwargs)
+
+ monkeypatch.setattr(model, "forward", mock_forward)
+
+ # 1. Unknown option in method_options for original movement
+ with pytest.raises((ValueError, TypeError)):
+ Optimizer(
+ model, loss, task="binary", method="original",
+ method_options={"completely_unknown_parameter_name": 123}
+ )
+ assert eval_calls == 0
+
+ # 2. Incompatible method option: negative_swarm with bare_bones
+ with pytest.raises(ValueError, match="unsupported"):
+ Optimizer(
+ model, loss, task="binary", method="bare_bones", negative_swarm=0.5
+ )
+ assert eval_calls == 0
+
+
+def test_repeated_fit_reinitializes_from_original_constructor_model_and_clears_early_stop(
+ model_factory, xor_data, monkeypatch
+):
+ """Verify repeated fit reinitializes base vector from original constructor model and clears early stopping state."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ orig_constructor_weights = torch.cat([p.detach().flatten() for p in model.parameters()]).clone()
+
+ opt = Optimizer(
+ model, loss, task="binary",
+ convergence="early_stopping",
+ convergence_patience=2,
+ seed=42,
+ )
+
+ score1 = opt.fit(x, y, epochs=3)
+ assert opt._global_best_weights is not None
+ first_run_best = opt._global_best_weights.clone()
+
+ early_plugin = opt.convergence_plugin
+ prepared_cleared = False
+ orig_prep = early_plugin.prepare_fit
+
+ def mock_prep(ctx):
+ nonlocal prepared_cleared
+ orig_prep(ctx)
+ if early_plugin.best_gbest_monitor is None and early_plugin.gbest_patience == 0:
+ prepared_cleared = True
+
+ monkeypatch.setattr(early_plugin, "prepare_fit", mock_prep)
+
+ # Second fit on same Optimizer instance
+ score2 = opt.fit(x, y, epochs=3)
+
+ # Particles in second fit must be initialized from orig_constructor_weights, NOT first_run_best
+ for p in opt.particles:
+ diff_from_orig = torch.norm(p.position.cpu() - orig_constructor_weights.cpu())
+ assert diff_from_orig < 5.0, "Particle position diverged from original constructor model base"
+
+ # Early stopping plugin state was cleared during prepare_fit
+ assert prepared_cleared is True
+
+
+def test_particle_reset_uses_original_constructor_base_vector(
+ model_factory, xor_data
+):
+ """Verify particle reset re-initializes position from the original constructor base_vector."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ orig_base = torch.cat([p.detach().flatten() for p in model.parameters()]).clone()
+
+ opt = Optimizer(
+ model, loss, task="binary",
+ convergence="particle_reset",
+ convergence_patience=1,
+ seed=42,
+ )
+ opt.fit(x, y, epochs=3)
+
+ for p in opt.particles:
+ assert p.position.shape == orig_base.shape
+
+
+def test_inertia_schedule_bounds_and_last_movement_w_min(model_factory, xor_data, monkeypatch):
+ """Verify inertia weight w stays in [w_min, w_max], starts at w_max and last movement reaches w_min."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ w_min_val, w_max_val = 0.1, 0.9
+ opt = Optimizer(
+ model, loss, task="binary", method="inertia",
+ w_min=w_min_val, w_max=w_max_val, n_particles=2, seed=42
+ )
+
+ recorded_w = []
+ orig_propose = opt.movement_plugin.propose
+
+ def mock_propose(particle_idx, state, context):
+ recorded_w.append(context.w)
+ return orig_propose(particle_idx, state, context)
+
+ monkeypatch.setattr(opt.movement_plugin, "propose", mock_propose)
+
+ epochs = 5
+ opt.fit(x, y, epochs=epochs)
+
+ # 2 particles per epoch * 4 epochs of movement = 8 propose calls
+ assert len(recorded_w) == 8
+
+ for w in recorded_w:
+ assert w_min_val <= w <= w_max_val
+
+ # Epoch 0 (first movement) uses w_max
+ assert math.isclose(recorded_w[0], w_max_val)
+ assert math.isclose(recorded_w[1], w_max_val)
+
+ # Epoch 3 (last movement before epoch 4 final evaluation) uses w_min
+ assert math.isclose(recorded_w[-1], w_min_val)
+ assert math.isclose(recorded_w[-2], w_min_val)
+def test_two_epoch_inertia_sole_movement_gets_w_max(model_factory, xor_data, monkeypatch):
+ """Verify in a 2-epoch run with inertia method, the sole movement step gets w_max."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ w_min_val, w_max_val = 0.1, 0.9
+ opt = Optimizer(
+ model, loss, task="binary", method="inertia",
+ w_min=w_min_val, w_max=w_max_val, n_particles=2, seed=42
+ )
+
+ recorded_w = []
+ orig_propose = opt.movement_plugin.propose
+
+ def mock_propose(particle_idx, state, context):
+ recorded_w.append(context.w)
+ return orig_propose(particle_idx, state, context)
+
+ monkeypatch.setattr(opt.movement_plugin, "propose", mock_propose)
+ opt.fit(x, y, epochs=2)
+
+ # 2-epoch fit has 1 movement step (epoch 0) across 2 particles = 2 propose calls
+ assert len(recorded_w) == 2
+ for w in recorded_w:
+ assert math.isclose(w, w_max_val)
+
+
+def test_standard_fit_no_swarm_snapshot_stacks(model_factory, xor_data, monkeypatch):
+ """Verify standard method fit does not perform swarm [N, D] snapshot stacks while preserving correct fit behavior."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(
+ model, loss, task="binary", method="inertia", n_particles=4, seed=42
+ )
+
+ orig_stack = torch.stack
+ snapshot_stack_calls = []
+
+ def mock_stack(tensors, dim=0, *args, **kwargs):
+ if isinstance(tensors, (list, tuple)) and len(tensors) == opt.n_particles:
+ first = tensors[0]
+ if isinstance(first, torch.Tensor) and first.ndim == 1:
+ snapshot_stack_calls.append(len(tensors))
+ return orig_stack(tensors, dim=dim, *args, **kwargs)
+
+ monkeypatch.setattr(torch, "stack", mock_stack)
+
+ score = opt.fit(x, y, epochs=3)
+ assert len(snapshot_stack_calls) == 0, f"Expected 0 swarm snapshot stacks, got {len(snapshot_stack_calls)}"
+ assert isinstance(score, tuple) and len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+ assert opt.get_best_model() is not None
+
+
+def test_optimizer_public_evaluate_contract(model_factory, xor_data):
+ """Verify public Optimizer.evaluate method raises pre-fit RuntimeError and has shape/type/aggregate parity for binary and multiclass."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt_binary = Optimizer(model, loss, task="binary", n_particles=2, seed=42)
+
+ # Pre-fit failure
+ with pytest.raises(RuntimeError, match="(?i)(not available|not been run)"):
+ opt_binary.evaluate(x, y)
+
+ # Binary evaluation parity
+ fit_score = opt_binary.fit(x, y, epochs=2)
+ eval_score = opt_binary.evaluate(x, y)
+
+ assert isinstance(eval_score, tuple) and len(eval_score) == 3
+ assert all(isinstance(s, float) and math.isfinite(s) for s in eval_score)
+ assert math.isclose(eval_score[0], fit_score[0], abs_tol=1e-5)
+ assert math.isclose(eval_score[1], fit_score[1], abs_tol=1e-5)
+ assert math.isclose(eval_score[2], fit_score[2], abs_tol=1e-5)
+
+ # Binary evaluation with batching
+ eval_batched = opt_binary.evaluate(x, y, batch_size=2)
+ assert isinstance(eval_batched, tuple) and len(eval_batched) == 3
+ assert all(isinstance(s, float) and math.isfinite(s) for s in eval_batched)
+
+ # Multiclass evaluation parity
+ mc_model = model_factory(input_dim=4, output_dim=3)
+ mc_loss = nn.CrossEntropyLoss()
+ opt_mc = Optimizer(mc_model, mc_loss, task="multiclass", n_particles=2, seed=42)
+
+ torch.manual_seed(42)
+ x_mc = torch.randn(6, 4)
+ y_mc_1d = torch.tensor([0, 1, 2, 0, 1, 2], dtype=torch.int64)
+ y_mc_2d = torch.nn.functional.one_hot(y_mc_1d, num_classes=3).float()
+
+ opt_mc.fit(x_mc, y_mc_1d, epochs=2)
+ score_1d = opt_mc.evaluate(x_mc, y_mc_1d)
+ score_2d = opt_mc.evaluate(x_mc, y_mc_2d)
+
+ assert isinstance(score_1d, tuple) and len(score_1d) == 3
+ assert isinstance(score_2d, tuple) and len(score_2d) == 3
+ assert all(isinstance(s, float) and math.isfinite(s) for s in score_1d)
+ assert all(isinstance(s, float) and math.isfinite(s) for s in score_2d)
+ assert math.isclose(score_1d[0], score_2d[0], abs_tol=1e-5)
+ assert math.isclose(score_1d[1], score_2d[1], abs_tol=1e-5)
+def test_fixed_subset_size_supplied_only_to_fit(model_factory, xor_data):
+ """Verify evaluation='fixed_subset' allows omitting fitness_size at Optimizer init and supplying it at fit."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(model, loss, task="binary", evaluation="fixed_subset")
+ assert opt.fitness_size is None
+
+ score = opt.fit(x, y, epochs=2, fitness_size=2)
+ assert isinstance(score, tuple) and len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+
+ # Omission at both init and fit fails during fit
+ opt2 = Optimizer(model, loss, task="binary", evaluation="fixed_subset")
+ with pytest.raises(ValueError, match="requires a positive fitness_size"):
+ opt2.fit(x, y, epochs=2)
+
+
+def test_final_evaluation_skips_movement_on_epoch_end_and_pbest_stacking(
+ model_factory, xor_data, monkeypatch
+):
+ """Verify final evaluation pass does not trigger movement on_epoch_end or stack CLPSO pbests."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(model, loss, task="binary", method="clpso", n_particles=3, seed=42)
+
+ epoch_end_calls = 0
+ orig_on_epoch_end = opt.movement_plugin.on_epoch_end
+
+ def spy_on_epoch_end(state, context):
+ nonlocal epoch_end_calls
+ epoch_end_calls += 1
+ return orig_on_epoch_end(state, context)
+
+ monkeypatch.setattr(opt.movement_plugin, "on_epoch_end", spy_on_epoch_end)
+
+ epochs = 3
+ opt.fit(x, y, epochs=epochs)
+
+ # For 3 epochs, on_epoch_end should be called between epochs (epochs - 1 = 2 times)
+ assert epoch_end_calls == 2, f"Expected 2 inter-epoch on_epoch_end calls for 3 epochs, got {epoch_end_calls}"
diff --git a/tests/test_optimizer.py:653-720 b/tests/test_optimizer.py:653-720
new file mode 100644
index 0000000..42ff19d
--- /dev/null
+++ b/tests/test_optimizer.py:653-720
@@ -0,0 +1,70 @@
+def test_binary_1d_target_normalization_no_broadcasting(model_factory):
+ """Verify binary [N, 1] logits model with 1-D [N] targets normalizes target shape and fits without broadcasting."""
+ torch.manual_seed(42)
+ x = torch.randn(6, 2, dtype=torch.float32)
+ y_1d = torch.tensor([0.0, 1.0, 1.0, 0.0, 1.0, 0.0], dtype=torch.float32) # Shape [6]
+
+ model = model_factory(input_dim=2, units=4, output_dim=1) # Output shape [6, 1]
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(model, loss, task="binary", n_particles=3, seed=42)
+ score = opt.fit(x, y_1d, epochs=2)
+
+ assert isinstance(score, tuple)
+ assert len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+
+
+def test_regression_1d_target_normalization_and_mse(model_factory):
+ """Verify regression [N, 1] model output with 1-D [N] targets normalizes shape, loss ≈ MSE, and no broadcasting."""
+ torch.manual_seed(42)
+ x = torch.randn(8, 2, dtype=torch.float32)
+ y_1d = torch.randn(8, dtype=torch.float32) # Shape [8]
+
+ model = model_factory(input_dim=2, units=4, output_dim=1) # Output shape [8, 1]
+ loss = nn.MSELoss()
+
+ opt = Optimizer(model, loss, task="regression", n_particles=3, seed=42)
+ score = opt.fit(x, y_1d, epochs=2)
+
+ assert isinstance(score, tuple)
+ assert len(score) == 3
+ assert all(math.isfinite(s) for s in score)
+ assert math.isclose(score[0], score[2], rel_tol=1e-5, abs_tol=1e-5)
+
+
+def test_binary_regression_incompatible_target_counts_fail_fast(model_factory):
+ """Verify binary and regression fail with contextual ValueError when target element count mismatches output."""
+ x = torch.randn(4, 2, dtype=torch.float32)
+ # Shape [4, 2] has leading dimension 4 (matches x), but 8 elements (mismatches model output [4, 1] 4 elements)
+ y_bad = torch.randn(4, 2, dtype=torch.float32)
+
+ model = model_factory(input_dim=2, units=4, output_dim=1) # Output shape [4, 1] -> 4 elements
+
+ opt_bin = Optimizer(model, nn.BCEWithLogitsLoss(), task="binary", n_particles=2)
+ with pytest.raises(ValueError, match="(?i)target element count"):
+ opt_bin.fit(x, y_bad)
+
+ opt_reg = Optimizer(model, nn.MSELoss(), task="regression", n_particles=2)
+ with pytest.raises(ValueError, match="(?i)target element count"):
+ opt_reg.fit(x, y_bad)
+
+
+def test_multiclass_target_shapes_and_incompatible_fail_fast(model_factory):
+ """Verify multiclass fits with [N, 1] integer targets reshaped to [N], and incompatible target shapes fail."""
+ x = torch.randn(6, 4, dtype=torch.float32)
+ # [N, 1] integer class targets
+ y_col = torch.tensor([[0], [1], [2], [0], [1], [2]], dtype=torch.int64)
+
+ model = model_factory(input_dim=4, units=8, output_dim=3) # Output shape [6, 3]
+ loss = nn.CrossEntropyLoss()
+
+ opt = Optimizer(model, loss, task="multiclass", n_particles=3, seed=42)
+ score = opt.fit(x, y_col, epochs=2)
+ assert isinstance(score, tuple)
+ assert all(math.isfinite(s) for s in score)
+
+ # Incompatible target shape (e.g. 5 columns for 3 classes)
+ y_bad = torch.randn(6, 5, dtype=torch.float32)
+ with pytest.raises(ValueError, match="(?i)target shape"):
+ opt.fit(x, y_bad)
diff --git a/tests/test_plugins.py b/tests/test_plugins.py
new file mode 100644
index 0000000..9cfb19f
--- /dev/null
+++ b/tests/test_plugins.py
@@ -0,0 +1,1139 @@
+import json
+import math
+import pytest
+import torch
+import torch.nn as nn
+
+import pso
+from pso import Optimizer
+from pso.plugins import (
+ BUILTIN_PLUGINS,
+ BasePlugin,
+ InitializationPlugin,
+ EvaluationPlugin,
+ MovementPlugin,
+ ConvergencePlugin,
+ RefinementPlugin,
+ PluginMetadata,
+ SwarmState,
+ FitContext,
+ IterationContext,
+ OriginalMovement,
+ InertiaMovement,
+ ConstrictionMovement,
+ FIPSMovement,
+ CLPSOMovement,
+ BareBonesMovement,
+ AdaptiveMomentMovement,
+ RingLocalBestMovement,
+ QuantumMovement,
+ ModelNoiseInitialization,
+ UniformInitialization,
+ FullEvaluation,
+ FixedSubsetEvaluation,
+ NoConvergence,
+ ParticleResetConvergence,
+ EarlyStoppingConvergence,
+ NoRefinement,
+ AdamRefinement,
+ available_plugins,
+ get_plugin,
+)
+from pso.optimizer import _RandomSource
+
+
+def test_metadata_registry_and_public_exports():
+ """Verify registry listing, stage filtering, and metadata properties across all plugins."""
+ all_stages = available_plugins()
+ assert set(all_stages.keys()) == {
+ "movement",
+ "initialization",
+ "evaluation",
+ "convergence",
+ "refinement",
+ }
+
+ movement_plugins = available_plugins(stage="movement")
+ expected_movement_keys = {
+ "original",
+ "inertia",
+ "constriction",
+ "fips",
+ "clpso",
+ "bare_bones",
+ "adaptive_moment",
+ "local_best",
+ "quantum",
+ }
+ assert set(movement_plugins.keys()) == expected_movement_keys
+
+ for stage, stage_dict in BUILTIN_PLUGINS.items():
+ for name, cls in stage_dict.items():
+ plugin = cls()
+ meta = plugin.metadata
+ assert isinstance(meta, PluginMetadata)
+ assert meta.stage == stage
+ assert isinstance(meta.title, str) and len(meta.title) > 0
+ assert meta.fidelity in ("canonical", "experimental")
+ assert isinstance(meta.gradient_required, bool)
+
+ # Check specific provenance/fidelity invariants
+ orig_meta = OriginalMovement.metadata
+ assert orig_meta.title == "Original PSO"
+ assert orig_meta.source == "10.1109/ICNN.1995.488968"
+ assert orig_meta.gradient_required is False
+ assert orig_meta.fidelity == "canonical"
+
+ am_meta = AdaptiveMomentMovement.metadata
+ assert am_meta.source is None
+ assert am_meta.fidelity == "experimental"
+
+ adam_meta = AdamRefinement.metadata
+ assert adam_meta.gradient_required is True
+
+
+def test_default_original_movement_formula():
+ """Verify default movement ('original') has c0=c1=2.0 and no inertia velocity scaling."""
+ rng = _RandomSource(seed=42)
+ orig = OriginalMovement()
+ assert orig.c0 == 2.0
+ assert orig.c1 == 2.0
+
+ pos = torch.tensor([[1.0, 2.0]])
+ vel = torch.tensor([[0.5, -0.5]])
+ pbest = torch.tensor([[3.0, 4.0]])
+ gbest = torch.tensor([5.0, 6.0])
+
+ state = SwarmState(
+ positions=(pos[0],),
+ velocities=(vel[0],),
+ pbest_positions=(pbest[0],),
+ pbest_scores=((0.5, 0.5, 0.5),),
+ gbest_position=gbest,
+ gbest_score=(0.5, 0.5, 0.5),
+ pbest_improved=(False,),
+ )
+ context = IterationContext(
+ epoch=0, total_epochs=10, w=0.5, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+
+ r1 = rng.uniform(pos[0].shape, 0.0, 1.0)
+ r2 = rng.uniform(pos[0].shape, 0.0, 1.0)
+
+ # Reset seed to reproduce exact r1, r2
+ rng = _RandomSource(seed=42)
+ context.rng = rng
+ x_new, v_new = orig.propose(0, state, context)
+
+ expected_vel = vel[0] + 2.0 * r1 * (pbest[0] - pos[0]) + 2.0 * r2 * (gbest - pos[0])
+ assert x_new is None
+ assert torch.allclose(v_new, expected_vel)
+
+
+def test_exact_one_step_movement_variants():
+ """Verify deterministic single-step movement calculation for all movement plugins."""
+ pos = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
+ vel = torch.tensor([[0.1, -0.1], [0.2, -0.2]])
+ pbest = torch.tensor([[2.0, 3.0], [4.0, 5.0]])
+ gbest = torch.tensor([5.0, 6.0])
+
+ state = SwarmState(
+ positions=tuple(pos),
+ velocities=tuple(vel),
+ pbest_positions=tuple(pbest),
+ pbest_scores=((0.5, 0.5, 0.5), (0.4, 0.4, 0.4)),
+ gbest_position=gbest,
+ gbest_score=(0.4, 0.4, 0.4),
+ pbest_improved=(False, False),
+ )
+
+ # 1. Inertia
+ rng = _RandomSource(seed=42)
+ inertia = InertiaMovement(c0=0.5, c1=0.5, w_min=0.1, w_max=0.9)
+ ctx_inertia = IterationContext(
+ epoch=0, total_epochs=5, w=0.9, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ r1 = rng.uniform(pos[0].shape, 0.0, 1.0)
+ r2 = rng.uniform(pos[0].shape, 0.0, 1.0)
+ rng = _RandomSource(seed=42)
+ ctx_inertia.rng = rng
+ _, v_inertia = inertia.propose(0, state, ctx_inertia)
+ expected_inertia_v = 0.9 * vel[0] + 0.5 * r1 * (pbest[0] - pos[0]) + 0.5 * r2 * (gbest - pos[0])
+ assert torch.allclose(v_inertia, expected_inertia_v)
+
+ # 2. Constriction
+ rng = _RandomSource(seed=42)
+ const = ConstrictionMovement(c0=2.05, c1=2.05)
+ ctx_const = IterationContext(
+ epoch=0, total_epochs=5, w=1.0, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ r1 = rng.uniform(pos[0].shape, 0.0, 1.0)
+ r2 = rng.uniform(pos[0].shape, 0.0, 1.0)
+ rng = _RandomSource(seed=42)
+ ctx_const.rng = rng
+ _, v_const = const.propose(0, state, ctx_const)
+ expected_const_v = const.chi * (vel[0] + 2.05 * r1 * (pbest[0] - pos[0]) + 2.05 * r2 * (gbest - pos[0]))
+ assert torch.allclose(v_const, expected_const_v)
+
+ # 3. FIPS
+ rng = _RandomSource(seed=42)
+ fips = FIPSMovement(c0=2.05, c1=2.05)
+ ctx_fips = IterationContext(
+ epoch=0, total_epochs=5, w=1.0, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ r1 = rng.uniform(pos[0].shape, 0.0, 4.1 / 2.0)
+ r2 = rng.uniform(pos[0].shape, 0.0, 4.1 / 2.0)
+ rng = _RandomSource(seed=42)
+ ctx_fips.rng = rng
+ _, v_fips = fips.propose(0, state, ctx_fips)
+ expected_fips_v = fips.chi * (vel[0] + r1 * (pbest[0] - pos[0]) + r2 * (pbest[1] - pos[0]))
+ assert torch.allclose(v_fips, expected_fips_v)
+
+ # 4. CLPSO
+ clpso = CLPSOMovement()
+ fit_ctx = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=pos[0], n_particles=2, particle_min=-5.0, particle_max=5.0,
+ velocity_limit=None, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=rng, task="binary",
+ x_train=torch.zeros((1, 1)), y_train=torch.zeros((1, 1)), batch_size=None,
+ fitness_size=None, renewal="acc", epochs=5, refinement_epochs=0, refinement_lr=0.001,
+ )
+ clpso.prepare_fit(fit_ctx)
+ ctx_clpso = IterationContext(
+ epoch=0, total_epochs=5, w=0.9, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ _, v_clpso = clpso.propose(0, state, ctx_clpso)
+ assert v_clpso is not None and v_clpso.shape == pos[0].shape
+
+ # 5. Bare Bones
+ rng = _RandomSource(seed=42)
+ bb = BareBonesMovement()
+ ctx_bb = IterationContext(
+ epoch=0, total_epochs=5, w=1.0, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ x_bb, v_bb = bb.propose(0, state, ctx_bb)
+ assert x_bb is not None
+ assert torch.equal(v_bb, torch.zeros_like(pos[0]))
+
+ # 6. Adaptive Moment
+ am = AdaptiveMomentMovement(moment_blend=0.5)
+ am.prepare_fit(fit_ctx)
+ ctx_am = IterationContext(
+ epoch=0, total_epochs=5, w=0.5, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ _, v_am = am.propose(0, state, ctx_am)
+ assert v_am is not None and v_am.shape == pos[0].shape
+ # 7. Ring Local Best
+ rng = _RandomSource(seed=42)
+ ring_mov = RingLocalBestMovement(c0=1.49618, c1=1.49618, w_min=0.4, w_max=0.9, neighborhood_radius=1)
+ ctx_ring = IterationContext(
+ epoch=0, total_epochs=5, w=0.9, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ r1 = rng.uniform(pos[0].shape, 0.0, 1.0)
+ r2 = rng.uniform(pos[0].shape, 0.0, 1.0)
+ rng = _RandomSource(seed=42)
+ ctx_ring.rng = rng
+ _, v_ring = ring_mov.propose(0, state, ctx_ring)
+ # For particle 0 with scores (0.5, 0.5, 0.5) vs particle 1 (0.4, 0.4, 0.4), under renewal="acc", particle 0 has higher acc (0.5 > 0.4), so lbest = pbest[0]
+ expected_ring_v = 0.9 * vel[0] + 1.49618 * r1 * (pbest[0] - pos[0]) + 1.49618 * r2 * (pbest[0] - pos[0])
+ assert torch.allclose(v_ring, expected_ring_v)
+
+ # 8. Quantum
+ rng = _RandomSource(seed=42)
+ q_mov = QuantumMovement(beta_min=0.5, beta_max=1.0)
+ ctx_q = IterationContext(
+ epoch=1, total_epochs=5, w=1.0, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ phi = rng.uniform(pos[0].shape, 0.0, 1.0)
+ u = rng.uniform(pos[0].shape, 0.0, 1.0)
+ sign_rand = rng.uniform(pos[0].shape, 0.0, 1.0)
+ rng = _RandomSource(seed=42)
+ ctx_q.rng = rng
+ x_q, v_q = q_mov.propose(0, state, ctx_q)
+ mbest_expected = (pbest[0] + pbest[1]) / 2.0
+ p_exp = phi * pbest[0] + (1.0 - phi) * gbest
+ u_clamped = torch.clamp(u, min=1e-10, max=1.0)
+ ln_u_inv = torch.log(1.0 / u_clamped)
+ sign_exp = torch.where(sign_rand < 0.5, 1.0, -1.0)
+ # epoch=1 in total_epochs=5 -> beta = beta_max = 1.0
+ expected_x_q = p_exp + sign_exp * 1.0 * torch.abs(mbest_expected - pos[0]) * ln_u_inv
+ assert torch.allclose(x_q, expected_x_q)
+ assert torch.equal(v_q, torch.zeros_like(pos[0]))
+
+ # The final applied move (epoch=T-1) reaches beta_min exactly.
+ final_rng = _RandomSource(seed=42)
+ ctx_q_final = IterationContext(
+ epoch=4,
+ total_epochs=5,
+ w=1.0,
+ particle_idx=0,
+ is_negative=False,
+ rng=final_rng,
+ optimizer=None,
+ )
+ x_q_final, _ = q_mov.propose(0, state, ctx_q_final)
+ expected_x_q_final = (
+ p_exp
+ + sign_exp
+ * 0.5
+ * torch.abs(mbest_expected - pos[0])
+ * ln_u_inv
+ )
+ assert torch.allclose(x_q_final, expected_x_q_final)
+
+
+def test_selector_and_incompatible_option_validation(model_factory, xor_data):
+ """Verify fail-fast behavior for invalid plugin selectors and incompatible stage options."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ # Invalid stage selector strings
+ with pytest.raises(ValueError, match="Unknown stage"):
+ available_plugins(stage="nonexistent")
+
+ with pytest.raises(ValueError, match="Unknown movement plugin"):
+ Optimizer(model, loss, task="binary", method="nonexistent")
+
+ with pytest.raises(ValueError, match="Unknown initialization plugin"):
+ Optimizer(model, loss, task="binary", initialization="nonexistent")
+
+ with pytest.raises(ValueError, match="Unknown evaluation plugin"):
+ Optimizer(model, loss, task="binary", evaluation="nonexistent")
+
+ with pytest.raises(ValueError, match="Unknown convergence plugin"):
+ Optimizer(model, loss, task="binary", convergence="nonexistent")
+
+ with pytest.raises(ValueError, match="Unknown refinement plugin"):
+ Optimizer(model, loss, task="binary", refinement="nonexistent")
+
+ # Constriction c0 + c1 <= 4.0
+ with pytest.raises(ValueError, match=r"c0 \+ c1 > 4\.0"):
+ ConstrictionMovement(c0=2.0, c1=2.0)
+
+ # BareBones unsupported options
+ bb = BareBonesMovement()
+ rng = _RandomSource(seed=42)
+ fit_ctx_bb_bad = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=torch.tensor([0.0]), n_particles=1, particle_min=None, particle_max=None,
+ velocity_limit=1.0, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=rng, task="binary",
+ x_train=torch.zeros((1, 1)), y_train=torch.zeros((1, 1)), batch_size=None,
+ fitness_size=None, renewal="acc", epochs=1, refinement_epochs=0, refinement_lr=0.001,
+ )
+ with pytest.raises(ValueError, match="unsupported for Bare Bones"):
+ bb.prepare_fit(fit_ctx_bb_bad)
+
+ # Uniform initialization requires bounds
+ uni = UniformInitialization()
+ fit_ctx_uni_bad = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=torch.tensor([0.0]), n_particles=1, particle_min=None, particle_max=None,
+ velocity_limit=None, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=rng, task="binary",
+ x_train=torch.zeros((1, 1)), y_train=torch.zeros((1, 1)), batch_size=None,
+ fitness_size=None, renewal="acc", epochs=1, refinement_epochs=0, refinement_lr=0.001,
+ )
+ with pytest.raises(ValueError, match="particle_min and particle_max"):
+ uni.initialize(0, torch.tensor([0.0]), fit_ctx_uni_bad)
+
+ # fitness_size with evaluation='full'
+ with pytest.raises(ValueError, match="fitness_size is only valid with evaluation='fixed_subset'"):
+ Optimizer(model, loss, task="binary", evaluation="full", fitness_size=2)
+
+ # evaluation='fixed_subset' without fitness_size at constructor or fit time fails during fit
+ opt_fs = Optimizer(model, loss, task="binary", evaluation="fixed_subset")
+ with pytest.raises(ValueError, match="requires a positive fitness_size"):
+ opt_fs.fit(x, y)
+
+ # refinement_epochs > 0 with refinement='none'
+ with pytest.raises(ValueError, match="refinement_epochs > 0 is valid only with refinement='adam'"):
+ Optimizer(model, loss, task="binary", refinement="none", refinement_epochs=5)
+
+ # Preconfigured custom MovementPlugin with conflicting kwarg
+ custom_mov = InertiaMovement(c0=0.8, c1=0.8)
+ with pytest.raises(ValueError, match="Conflicting parameter"):
+ Optimizer(model, loss, task="binary", method=custom_mov, c0=0.5)
+
+
+def test_evaluation_stage_semantics(model_factory):
+ """Verify FullEvaluation and FixedSubsetEvaluation sample handling across epochs."""
+ x = torch.randn(20, 2)
+ y = torch.randint(0, 2, (20, 1)).float()
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ rng = _RandomSource(seed=42)
+
+ # Full evaluation
+ full_eval = FullEvaluation()
+ fit_ctx_full = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=torch.tensor([0.0]), n_particles=2, particle_min=None, particle_max=None,
+ velocity_limit=None, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=rng, task="binary",
+ x_train=x, y_train=y, batch_size=None, fitness_size=None, renewal="acc",
+ epochs=3, refinement_epochs=0, refinement_lr=0.001,
+ )
+ full_eval.prepare_fit(fit_ctx_full)
+ xf1, yf1 = full_eval.get_fitness_data(x, y, fit_ctx_full)
+ xf2, yf2 = full_eval.get_fitness_data(x, y, fit_ctx_full)
+ assert torch.equal(xf1, x) and torch.equal(xf2, x)
+
+ # Fixed subset evaluation
+ fixed_eval = FixedSubsetEvaluation(fitness_size=5)
+ fit_ctx_fixed = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=torch.tensor([0.0]), n_particles=2, particle_min=None, particle_max=None,
+ velocity_limit=None, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=rng, task="binary",
+ x_train=x, y_train=y, batch_size=None, fitness_size=5, renewal="acc",
+ epochs=3, refinement_epochs=0, refinement_lr=0.001,
+ )
+ fixed_eval.prepare_fit(fit_ctx_fixed)
+ xs1, ys1 = fixed_eval.get_fitness_data(x, y, fit_ctx_fixed)
+ xs2, ys2 = fixed_eval.get_fitness_data(x, y, fit_ctx_fixed)
+ assert xs1.shape[0] == 5
+ assert torch.equal(xs1, xs2) and torch.equal(ys1, ys2)
+
+
+def test_every_fit_fresh_state_lifecycle(model_factory, xor_data):
+ """Verify repeated fit() reinitializes all stage plugins and swarm state completely."""
+ x, y = xor_data
+ model1 = model_factory()
+ model2 = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt1 = Optimizer(
+ model1, loss, task="binary",
+ method="adaptive_moment",
+ convergence="particle_reset",
+ refinement="adam",
+ n_particles=4, seed=42,
+ moment_blend=0.5,
+ convergence_patience=2,
+ )
+ opt2 = Optimizer(
+ model2, loss, task="binary",
+ method="adaptive_moment",
+ convergence="particle_reset",
+ refinement="adam",
+ n_particles=4, seed=42,
+ moment_blend=0.5,
+ convergence_patience=2,
+ )
+
+ # Independent seeded runs yield identical best weights and score
+ score1 = opt1.fit(x, y, epochs=3, refinement_epochs=2)
+ score2 = opt2.fit(x, y, epochs=3, refinement_epochs=2)
+ assert score1 == score2
+ assert torch.equal(opt1._global_best_weights, opt2._global_best_weights)
+
+ # Second fit on opt1 clears global best and creates fresh particles & plugin state
+ score1_run2 = opt1.fit(x, y, epochs=3, refinement_epochs=2)
+ assert len(opt1.particles) == 4
+ assert opt1._global_best_weights is not None
+ assert all(math.isfinite(s) for s in score1_run2)
+
+
+def test_convergence_stage_semantics(model_factory, xor_data):
+ """Verify NoConvergence, ParticleResetConvergence, and EarlyStoppingConvergence behavior."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ rng = _RandomSource(seed=42)
+
+ # 1. NoConvergence
+ no_conv = NoConvergence()
+ iter_ctx0 = IterationContext(
+ epoch=0, total_epochs=10, w=0.5, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ assert no_conv.on_epoch_end((0.5, 0.5, 0.5), True, iter_ctx0) is False
+
+ # 2. EarlyStoppingConvergence stops when patience is reached
+ early_conv = EarlyStoppingConvergence(patience=2, min_delta=0.01, monitor="loss")
+ fit_ctx = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=torch.tensor([0.0]), n_particles=2, particle_min=None, particle_max=None,
+ velocity_limit=None, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=rng, task="binary",
+ x_train=x, y_train=y, batch_size=None, fitness_size=None, renewal="acc",
+ epochs=10, refinement_epochs=0, refinement_lr=0.001,
+ )
+ early_conv.prepare_fit(fit_ctx)
+
+ # Epoch 0: initial gbest loss 0.5 (improved)
+ iter_ctx1 = IterationContext(
+ epoch=0, total_epochs=10, w=0.5, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ stop0 = early_conv.on_epoch_end((0.5, 0.5, 0.5), True, iter_ctx1)
+ assert stop0 is False
+
+ # Epoch 1: no improvement (gbest_improved=False) -> patience 1
+ iter_ctx2 = IterationContext(
+ epoch=1, total_epochs=10, w=0.5, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ stop1 = early_conv.on_epoch_end((0.5, 0.5, 0.5), False, iter_ctx2)
+ assert stop1 is False
+
+ # Epoch 2: no improvement (gbest_improved=False) -> patience 2 -> triggers stop
+ iter_ctx3 = IterationContext(
+ epoch=2, total_epochs=10, w=0.5, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ stop2 = early_conv.on_epoch_end((0.5, 0.5, 0.5), False, iter_ctx3)
+ assert stop2 is True
+
+ # 3. Integrated early stopping test
+ opt_es = Optimizer(
+ model, loss, task="binary", convergence="early_stopping", convergence_patience=2, seed=42
+ )
+ score_es = opt_es.fit(x, y, epochs=100)
+ assert all(math.isfinite(s) for s in score_es)
+
+
+def test_refinement_stage_semantics(model_factory, xor_data):
+ """Verify NoRefinement and AdamRefinement contracts and gradient detachment."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ no_ref = NoRefinement()
+ pos = torch.tensor([0.1, 0.2])
+ score = (0.5, 0.5, 0.5)
+ fit_ctx = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=torch.tensor([0.0]), n_particles=2, particle_min=None, particle_max=None,
+ velocity_limit=None, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=_RandomSource(seed=42), task="binary",
+ x_train=x, y_train=y, batch_size=None, fitness_size=None, renewal="acc",
+ epochs=10, refinement_epochs=0, refinement_lr=0.001,
+ )
+ r_pos, r_score = no_ref.refine(pos, score, None, fit_ctx)
+ assert torch.equal(r_pos, pos) and r_score == score
+
+ adam_ref = AdamRefinement(epochs=5, lr=0.01)
+ opt = Optimizer(model, loss, task="binary", refinement="adam", seed=42)
+ score_res = opt.fit(x, y, epochs=2, refinement_epochs=5, refinement_lr=0.01)
+
+ assert all(math.isfinite(s) for s in score_res)
+ assert opt._global_best_weights is not None
+ assert opt._global_best_weights.requires_grad is False
+
+def test_adaptive_moment_allocation_guarantee(model_factory, xor_data):
+ """Verify moments are NOT allocated when moment_blend=0.0 or standard methods used, and ARE allocated when moment_blend>0."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ # Standard method ('original') -> no moment plugin state
+ opt_orig = Optimizer(model, loss, task="binary", method="original", seed=42)
+ opt_orig.fit(x, y, epochs=2)
+ assert not isinstance(opt_orig.movement_plugin, AdaptiveMomentMovement)
+
+ # Adaptive moment with moment_blend=0.0 -> moment tensors remain None
+ opt_am_zero = Optimizer(
+ model, loss, task="binary", method="adaptive_moment", moment_blend=0.0, seed=42
+ )
+ opt_am_zero.fit(x, y, epochs=2)
+ am_zero = opt_am_zero.movement_plugin
+ assert isinstance(am_zero, AdaptiveMomentMovement)
+ for m1, m2 in zip(am_zero.first_moments, am_zero.second_moments):
+ assert m1 is None
+ assert m2 is None
+
+ # Adaptive moment with moment_blend=0.5 -> moment tensors allocated and initialized to zero
+ opt_am_active = Optimizer(
+ model, loss, task="binary", method="adaptive_moment", moment_blend=0.5, seed=42
+ )
+ opt_am_active.fit(x, y, epochs=2)
+ am_active = opt_am_active.movement_plugin
+ assert isinstance(am_active, AdaptiveMomentMovement)
+ for m1, m2 in zip(am_active.first_moments, am_active.second_moments):
+ assert isinstance(m1, torch.Tensor)
+ assert isinstance(m2, torch.Tensor)
+ assert m1.requires_grad is False
+ assert m2.requires_grad is False
+
+
+def test_run_json_provenance_and_selector_fields(model_factory, xor_data, tmp_path):
+ """Verify run.json config dictionary records stage selectors and plugin metadata provenance."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(
+ model, loss, task="binary",
+ method="inertia",
+ initialization="model_noise",
+ evaluation="fixed_subset",
+ convergence="early_stopping",
+ refinement="adam",
+ fitness_size=2,
+ convergence_patience=5,
+ refinement_epochs=10,
+ seed=42,
+ )
+
+ opt.fit(x, y, epochs=2, save_info=True, output_dir=tmp_path)
+
+ run_file = tmp_path / "run.json"
+ assert run_file.exists()
+
+ with open(run_file, "r", encoding="utf-8") as f:
+ info = json.load(f)
+
+ assert info["version"] == pso.__version__
+ cfg = info["config"]
+ assert cfg["method"] == "inertia"
+ assert cfg["initialization"] == "model_noise"
+ assert cfg["evaluation"] == "fixed_subset"
+ assert cfg["convergence"] == "early_stopping"
+ assert cfg["refinement"] == "adam"
+
+ plugins_meta = cfg["plugins"]
+ assert plugins_meta["movement"]["title"] == "Inertia Weight PSO"
+ assert plugins_meta["movement"]["source"] == "10.1109/ICEC.1998.699146"
+ assert plugins_meta["movement"]["fidelity"] == "canonical"
+ assert plugins_meta["movement"]["gradient_required"] is False
+
+ assert plugins_meta["refinement"]["title"] == "Adam Post-Search Refinement"
+ assert plugins_meta["refinement"]["gradient_required"] is True
+
+
+def test_exact_doi_metadata_across_all_plugins():
+ """Verify exact DOI source metadata across all builtin plugins."""
+ expected_sources = {
+ "original": "10.1109/ICNN.1995.488968",
+ "inertia": "10.1109/ICEC.1998.699146",
+ "constriction": "10.1109/4235.985692",
+ "fips": "10.1109/TEVC.2004.826074",
+ "clpso": "10.1109/TEVC.2005.857610",
+ "bare_bones": "10.1109/SIS.2003.1202251",
+ "adaptive_moment": None,
+ "local_best": "10.1109/CEC.2002.1004493",
+ "quantum": "10.1109/CEC.2004.1330875",
+ }
+ for name, expected_source in expected_sources.items():
+ assert BUILTIN_PLUGINS["movement"][name]().metadata.source == expected_source
+
+ for stage, stage_dict in BUILTIN_PLUGINS.items():
+ if stage == "movement":
+ continue
+ for name, cls in stage_dict.items():
+ if stage == "refinement" and name == "adam":
+ assert cls().metadata.source == "10.1016/j.amc.2006.07.025"
+ else:
+ assert cls().metadata.source is None
+
+
+def test_canonical_inertia_defaults_and_movement():
+ """Verify canonical inertia movement defaults and exact one-step formula."""
+ rng = _RandomSource(seed=42)
+ inertia = InertiaMovement(c0=2.0, c1=2.0, w_min=0.4, w_max=0.9)
+ assert inertia.c0 == 2.0
+ assert inertia.c1 == 2.0
+ assert inertia.w_min == 0.4
+ assert inertia.w_max == 0.9
+
+ pos = torch.tensor([[1.0, 2.0]])
+ vel = torch.tensor([[0.5, -0.5]])
+ pbest = torch.tensor([[3.0, 4.0]])
+ gbest = torch.tensor([5.0, 6.0])
+
+ state = SwarmState(
+ positions=(pos[0],),
+ velocities=(vel[0],),
+ pbest_positions=(pbest[0],),
+ pbest_scores=((0.5, 0.5, 0.5),),
+ gbest_position=gbest,
+ gbest_score=(0.5, 0.5, 0.5),
+ pbest_improved=(False,),
+ )
+ context = IterationContext(
+ epoch=0, total_epochs=5, w=0.9, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+
+ r1 = rng.uniform(pos[0].shape, 0.0, 1.0)
+ r2 = rng.uniform(pos[0].shape, 0.0, 1.0)
+
+ rng = _RandomSource(seed=42)
+ context.rng = rng
+ _, v_new = inertia.propose(0, state, context)
+
+ expected_vel = 0.9 * vel[0] + 2.0 * r1 * (pbest[0] - pos[0]) + 2.0 * r2 * (gbest - pos[0])
+ assert torch.allclose(v_new, expected_vel)
+
+
+def test_adaptive_moment_string_default_allocates_nonzero_moments(model_factory, xor_data):
+ """Verify adaptive_moment string selector defaults to moment_blend=0.25 and allocates moments."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(model, loss, task="binary", method="adaptive_moment", seed=42)
+ am = opt.movement_plugin
+ assert isinstance(am, AdaptiveMomentMovement)
+ assert am.moment_blend == 0.25
+
+ opt.fit(x, y, epochs=2)
+ assert len(am.first_moments) == opt.n_particles
+ assert len(am.second_moments) == opt.n_particles
+ for m1, m2 in zip(am.first_moments, am.second_moments):
+ assert isinstance(m1, torch.Tensor)
+ assert isinstance(m2, torch.Tensor)
+ assert m1.requires_grad is False
+ assert m2.requires_grad is False
+
+ has_nonzero = any(torch.norm(m1) > 0.0 for m1 in am.first_moments)
+ assert has_nonzero
+
+
+def test_clpso_tournament_uses_swarmstate_pbest_score_ordering():
+ """Verify CLPSO exemplar tournaments order candidates via SwarmState.pbest_scores."""
+ rng = _RandomSource(seed=42)
+ clpso = CLPSOMovement(c=1.49445, refresh_gap=2)
+ fit_ctx = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=torch.tensor([0.0, 0.0]), n_particles=2, particle_min=-5.0, particle_max=5.0,
+ velocity_limit=None, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=rng, task="binary",
+ x_train=torch.zeros((1, 2)), y_train=torch.zeros((1, 1)), batch_size=None,
+ fitness_size=None, renewal="acc", epochs=5, refinement_epochs=0, refinement_lr=0.001,
+ )
+ clpso.prepare_fit(fit_ctx)
+
+ pos = torch.tensor([[1.0, 1.0], [2.0, 2.0]])
+ vel = torch.tensor([[0.1, 0.1], [0.1, 0.1]])
+ pbest = torch.tensor([[1.0, 1.0], [2.0, 2.0]])
+ gbest = torch.tensor([2.0, 2.0])
+
+ state = SwarmState(
+ positions=tuple(pos),
+ velocities=tuple(vel),
+ pbest_positions=tuple(pbest),
+ pbest_scores=((0.8, 0.2, 0.8), (0.1, 0.9, 0.1)),
+ gbest_position=gbest,
+ gbest_score=(0.1, 0.9, 0.1),
+ pbest_improved=(False, False),
+ )
+
+ clpso.stagnation[0] = 2
+ iter_ctx = IterationContext(
+ epoch=2, total_epochs=5, w=0.9, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ clpso.on_epoch_end(state, iter_ctx)
+ assert clpso.stagnation[0] == 0
+
+def test_clpso_stagnation_reset_and_vectorized_exemplar_gather():
+ """Verify CLPSO improvement resets stagnation counter and vectorized exemplar gather selects expected pbest dimensions."""
+ rng = _RandomSource(seed=42)
+ clpso = CLPSOMovement(c=1.49445, refresh_gap=3)
+ fit_ctx = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=torch.tensor([0.0, 0.0]), n_particles=2, particle_min=-5.0, particle_max=5.0,
+ velocity_limit=None, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=rng, task="binary",
+ x_train=torch.zeros((1, 2)), y_train=torch.zeros((1, 1)), batch_size=None,
+ fitness_size=None, renewal="acc", epochs=5, refinement_epochs=0, refinement_lr=0.001,
+ )
+ clpso.prepare_fit(fit_ctx)
+
+ pos = torch.tensor([[1.0, 1.0], [2.0, 2.0]])
+ vel = torch.tensor([[0.1, 0.1], [0.1, 0.1]])
+ pbest = torch.tensor([[10.0, 20.0], [30.0, 40.0]])
+ gbest = torch.tensor([30.0, 40.0])
+
+ # Test 1: Improvement resets stagnation
+ clpso.stagnation = torch.tensor([2, 2], dtype=torch.int64)
+ state_imp = SwarmState(
+ positions=tuple(pos),
+ velocities=tuple(vel),
+ pbest_positions=tuple(pbest),
+ pbest_scores=((0.8, 0.2, 0.8), (0.1, 0.9, 0.1)),
+ gbest_position=gbest,
+ gbest_score=(0.1, 0.9, 0.1),
+ pbest_improved=(True, False),
+ )
+ iter_ctx = IterationContext(
+ epoch=1, total_epochs=5, w=0.9, particle_idx=0, is_negative=False, rng=rng, optimizer=None
+ )
+ clpso.on_epoch_end(state_imp, iter_ctx)
+ assert clpso.stagnation[0] == 0 # Particle 0 improved -> stagnation reset to 0
+ # Test 2: Vectorized exemplar gather
+ # Particle 0 exemplars [0, 1]: dim0 from particle 0 pbest (10.0), dim1 from particle 1 pbest (40.0)
+ clpso.exemplars = torch.tensor([[0, 1], [1, 0]], dtype=torch.int64)
+
+ rng_p0 = _RandomSource(seed=42)
+ iter_ctx_p0 = IterationContext(
+ epoch=1, total_epochs=5, w=0.9, particle_idx=0, is_negative=False, rng=rng_p0, optimizer=None
+ )
+ r_mock = _RandomSource(seed=42).uniform(pos[0].shape, 0.0, 1.0)
+
+ _, v0_new = clpso.propose(0, state_imp, iter_ctx_p0)
+ expected_e0 = torch.tensor([10.0, 40.0])
+ expected_v0 = 0.9 * vel[0] + 1.49445 * r_mock * (expected_e0 - pos[0])
+ assert torch.allclose(v0_new, expected_v0)
+def test_fixed_subset_adam_refinement_receives_sampled_fitness_tensors(
+ model_factory, xor_data, monkeypatch
+):
+ """Verify Adam refinement in fixed_subset mode operates on the exact sampled fitness tensors."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(
+ model, loss, task="binary",
+ evaluation="fixed_subset",
+ refinement="adam",
+ fitness_size=2,
+ refinement_epochs=2,
+ seed=42,
+ )
+
+ captured_refine_args = []
+ orig_refine = opt._refine
+
+ def mock_refine(x_fit, y_fit, **kwargs):
+ captured_refine_args.append((x_fit, y_fit))
+ return orig_refine(x_fit, y_fit, **kwargs)
+
+ monkeypatch.setattr(opt, "_refine", mock_refine)
+ opt.fit(x, y, epochs=1, refinement_epochs=2)
+
+ assert len(captured_refine_args) == 1
+ x_fit_received, y_fit_received = captured_refine_args[0]
+ assert x_fit_received.shape[0] == 2
+ assert y_fit_received.shape[0] == 2
+
+
+def test_fit_context_and_run_json_moment_field_signatures(model_factory, xor_data, tmp_path):
+ """Verify FitContext and run.json signatures preserve all optional moment fields."""
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ opt = Optimizer(
+ model, loss, task="binary",
+ method="adaptive_moment",
+ moment_blend=0.3,
+ moment_beta1=0.85,
+ moment_beta2=0.99,
+ moment_step_size=0.8,
+ moment_epsilon=1e-7,
+ seed=42,
+ )
+ opt.fit(x, y, epochs=1, save_info=True, output_dir=tmp_path)
+
+ with open(tmp_path / "run.json", "r", encoding="utf-8") as f:
+ data = json.load(f)
+
+ cfg = data["config"]
+ assert cfg["moment_blend"] == 0.3
+ assert cfg["moment_beta1"] == 0.85
+ assert cfg["moment_beta2"] == 0.99
+ assert cfg["moment_step_size"] == 0.8
+ assert cfg["moment_epsilon"] == 1e-7
+def test_clpso_two_particle_all_own_fallback_chooses_external_exemplar():
+ """Verify CLPSO two-particle (k=1) all-own fallback selects external candidate for at least one dimension."""
+ clpso = CLPSOMovement(c=1.49, w_min=0.4, w_max=0.9, refresh_gap=7)
+ rng = _RandomSource(seed=42)
+ dim = 4
+
+ fit_ctx = FitContext(
+ optimizer=None,
+ model=None,
+ eval_model=None,
+ codec=None,
+ base_vector=torch.zeros(dim),
+ n_particles=2,
+ particle_min=None,
+ particle_max=None,
+ velocity_limit=None,
+ boundary_strategy="clip",
+ initial_position_noise=0.0,
+ seed=42,
+ device=torch.device("cpu"),
+ rng=rng,
+ task="binary",
+ x_train=torch.zeros((4, 2)),
+ y_train=torch.zeros((4, 1)),
+ batch_size=None,
+ fitness_size=None,
+ renewal="acc",
+ epochs=1,
+ refinement_epochs=0,
+ refinement_lr=0.001,
+ )
+ clpso.prepare_fit(fit_ctx)
+ clpso.learning_probs = torch.zeros((2,), dtype=torch.float32)
+
+ state = SwarmState(
+ positions=tuple([torch.zeros(dim), torch.zeros(dim)]),
+ velocities=tuple([torch.zeros(dim), torch.zeros(dim)]),
+ pbest_positions=tuple([torch.zeros(dim), torch.zeros(dim)]),
+ pbest_scores=((0.5, 0.5, 0.5), (0.4, 0.6, 0.4)),
+ gbest_position=torch.zeros(dim),
+ gbest_score=(0.4, 0.6, 0.4),
+ pbest_improved=(False, False),
+ )
+ clpso.on_epoch_end(state, fit_ctx)
+
+ clpso._sample_exemplars_for_particle(0, state, rng)
+ ex = clpso.exemplars[0]
+
+ assert not torch.all(ex == 0), "Particle 0 should not retain self-exemplar for all dimensions in fallback"
+ assert torch.any(ex == 1), "Particle 0 must select particle 1 for at least one dimension in two-particle fallback"
+
+
+def test_clpso_mse_tournament_ranking_order():
+ """Verify CLPSO on_epoch_end ranks candidates by MSE ascending, loss ascending, then accuracy descending."""
+ clpso = CLPSOMovement(c=1.49, w_min=0.4, w_max=0.9, refresh_gap=7)
+ rng = _RandomSource(seed=42)
+ dim = 2
+
+ fit_ctx = FitContext(
+ optimizer=None,
+ model=None,
+ eval_model=None,
+ codec=None,
+ base_vector=torch.zeros(dim),
+ n_particles=3,
+ particle_min=None,
+ particle_max=None,
+ velocity_limit=None,
+ boundary_strategy="clip",
+ initial_position_noise=0.0,
+ seed=42,
+ device=torch.device("cpu"),
+ rng=rng,
+ task="regression",
+ x_train=torch.zeros((4, 2)),
+ y_train=torch.zeros((4, 1)),
+ batch_size=None,
+ fitness_size=None,
+ renewal="mse",
+ epochs=1,
+ refinement_epochs=0,
+ refinement_lr=0.001,
+ )
+ clpso.prepare_fit(fit_ctx)
+
+ state = SwarmState(
+ positions=tuple([torch.zeros(dim)] * 3),
+ velocities=tuple([torch.zeros(dim)] * 3),
+ pbest_positions=tuple([torch.zeros(dim)] * 3),
+ pbest_scores=(
+ (0.5, 0.8, 0.1), # Particle 0: mse=0.1, loss=0.5, acc=0.8
+ (0.4, 0.8, 0.1), # Particle 1: mse=0.1, loss=0.4, acc=0.8 (same mse, lower loss -> rank 1 < rank 0)
+ (0.4, 0.9, 0.1), # Particle 2: mse=0.1, loss=0.4, acc=0.9 (same mse, same loss, higher acc -> rank 2 < rank 1)
+ ),
+ gbest_position=torch.zeros(dim),
+ gbest_score=(0.4, 0.9, 0.1),
+ pbest_improved=(False, False, False),
+ )
+ clpso.on_epoch_end(state, fit_ctx)
+
+ ranks = clpso._ranks
+ assert ranks[2] < ranks[1] < ranks[0], f"Expected ranks[2] < ranks[1] < ranks[0], got {ranks}"
+ assert ranks[2].item() == 0
+ assert ranks[1].item() == 1
+ assert ranks[0].item() == 2
+
+
+def test_clpso_exemplar_gather_device_normalization():
+ """Verify CLPSO propose handles CPU exemplar indices with normalized pbest matrix and particle device placement."""
+ clpso = CLPSOMovement(c=1.49, w_min=0.4, w_max=0.9, refresh_gap=7)
+ rng = _RandomSource(seed=42)
+ dim = 3
+
+ fit_ctx = FitContext(
+ optimizer=None,
+ model=None,
+ eval_model=None,
+ codec=None,
+ base_vector=torch.zeros(dim),
+ n_particles=2,
+ particle_min=None,
+ particle_max=None,
+ velocity_limit=None,
+ boundary_strategy="clip",
+ initial_position_noise=0.0,
+ seed=42,
+ device=torch.device("cpu"),
+ rng=rng,
+ task="binary",
+ x_train=torch.zeros((4, 2)),
+ y_train=torch.zeros((4, 1)),
+ batch_size=None,
+ fitness_size=None,
+ renewal="acc",
+ epochs=1,
+ refinement_epochs=0,
+ refinement_lr=0.001,
+ )
+ clpso.prepare_fit(fit_ctx)
+
+ clpso.exemplars = torch.tensor([[0, 1, 0], [1, 0, 1]], dtype=torch.int64, device="cpu")
+ clpso._pbest_matrix = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], dtype=torch.float32, device="cpu")
+ clpso._ranks = torch.tensor([0, 1], dtype=torch.int64, device="cpu")
+
+ state = SwarmState(
+ positions=tuple([torch.zeros(dim, dtype=torch.float32), torch.zeros(dim, dtype=torch.float32)]),
+ velocities=tuple([torch.zeros(dim, dtype=torch.float32), torch.zeros(dim, dtype=torch.float32)]),
+ pbest_positions=tuple([torch.zeros(dim), torch.zeros(dim)]),
+ pbest_scores=((0.1, 0.9, 0.1), (0.2, 0.8, 0.2)),
+ gbest_position=torch.zeros(dim),
+ gbest_score=(0.1, 0.9, 0.1),
+ pbest_improved=(False, False),
+ )
+
+ iter_ctx = IterationContext(
+ epoch=0,
+ total_epochs=1,
+ w=0.5,
+ particle_idx=0,
+ is_negative=False,
+ rng=rng,
+ optimizer=None,
+ )
+ pos_opt, vel_opt = clpso.propose(0, state, iter_ctx)
+ assert pos_opt is None
+ assert vel_opt is not None
+ assert vel_opt.device == state.positions[0].device
+ assert vel_opt.dtype == state.positions[0].dtype
+def test_ring_local_best_semantics(model_factory, xor_data):
+ """Verify RingLocalBestMovement topology, wrapped ring neighbor deduplication, and optimization."""
+ # Metadata assertions
+ plugin_meta = available_plugins(stage="movement")["local_best"]
+ assert plugin_meta.stage == "movement"
+ assert plugin_meta.title == "Ring Local Best PSO"
+ assert plugin_meta.source == "10.1109/CEC.2002.1004493"
+ assert plugin_meta.fidelity == "canonical"
+ assert plugin_meta.gradient_required is False
+
+ # Option validation
+ with pytest.raises(ValueError):
+ RingLocalBestMovement(c0=float("nan"))
+ with pytest.raises(ValueError):
+ RingLocalBestMovement(w_min=0.9, w_max=0.4)
+ with pytest.raises(ValueError):
+ RingLocalBestMovement(neighborhood_radius=0)
+ with pytest.raises(ValueError):
+ RingLocalBestMovement(neighborhood_radius=1.5)
+
+ # Wrapped ring deduplication for n=1 and n=2 swarms
+ mov = RingLocalBestMovement(neighborhood_radius=2)
+ pos = [torch.tensor([1.0, 1.0])]
+ vel = [torch.tensor([0.0, 0.0])]
+ pbest = [torch.tensor([2.0, 2.0])]
+ scores = [(0.5, 0.5, 0.5)]
+ state_n1 = SwarmState(
+ positions=tuple(pos),
+ velocities=tuple(vel),
+ pbest_positions=tuple(pbest),
+ pbest_scores=tuple(scores),
+ gbest_position=pbest[0],
+ gbest_score=scores[0],
+ pbest_improved=(False,),
+ )
+ rng = _RandomSource(seed=42)
+ ctx = IterationContext(epoch=1, total_epochs=5, w=0.5, particle_idx=0, is_negative=False, rng=rng, optimizer=None)
+ pos_over, vel_over = mov.propose(0, state_n1, ctx)
+ assert pos_over is None
+ assert vel_over is not None
+
+ # Full fit test with local_best
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+ opt = Optimizer(
+ model,
+ loss,
+ task="binary",
+ method="local_best",
+ c0=1.49618,
+ c1=1.49618,
+ w_min=0.4,
+ w_max=0.9,
+ seed=42,
+ )
+ res = opt.fit(x, y, epochs=5)
+ assert len(res) == 3
+ assert all(math.isfinite(s) for s in res)
+
+
+def test_quantum_movement_semantics(model_factory, xor_data):
+ """Verify QuantumMovement formula, beta scheduling, mbest caching, state resets, and error handling."""
+ # Metadata assertions
+ plugin_meta = available_plugins(stage="movement")["quantum"]
+ assert plugin_meta.stage == "movement"
+ assert plugin_meta.title == "Quantum PSO"
+ assert plugin_meta.source == "10.1109/CEC.2004.1330875"
+ assert plugin_meta.fidelity == "canonical"
+ assert plugin_meta.gradient_required is False
+
+ # Option validation
+ with pytest.raises(ValueError):
+ QuantumMovement(beta_min=1.2, beta_max=0.8)
+ with pytest.raises(ValueError):
+ QuantumMovement(beta_min=-0.1)
+
+ # Rejection of unsupported controls
+ q_mov = QuantumMovement()
+ fit_ctx = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=torch.zeros(2), n_particles=2, particle_min=None, particle_max=None,
+ velocity_limit=None, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=None, task="binary",
+ x_train=torch.zeros((1, 1)), y_train=torch.zeros((1, 1)), batch_size=None,
+ fitness_size=None, renewal="acc", epochs=5, refinement_epochs=0, refinement_lr=0.001,
+ negative_swarm=0.1,
+ )
+ with pytest.raises(ValueError, match="negative_swarm is unsupported"):
+ q_mov.prepare_fit(fit_ctx)
+
+ fit_ctx_mut = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=torch.zeros(2), n_particles=2, particle_min=None, particle_max=None,
+ velocity_limit=None, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=None, task="binary",
+ x_train=torch.zeros((1, 1)), y_train=torch.zeros((1, 1)), batch_size=None,
+ fitness_size=None, renewal="acc", epochs=5, refinement_epochs=0, refinement_lr=0.001,
+ mutation_swarm=0.1,
+ )
+ with pytest.raises(ValueError, match="mutation_swarm is unsupported"):
+ q_mov.prepare_fit(fit_ctx_mut)
+
+ fit_ctx_vlim = FitContext(
+ optimizer=None, model=None, eval_model=None, codec=None,
+ base_vector=torch.zeros(2), n_particles=2, particle_min=None, particle_max=None,
+ velocity_limit=0.5, boundary_strategy="clip", initial_position_noise=0.0,
+ seed=42, device=torch.device("cpu"), rng=None, task="binary",
+ x_train=torch.zeros((1, 1)), y_train=torch.zeros((1, 1)), batch_size=None,
+ fitness_size=None, renewal="acc", epochs=5, refinement_epochs=0, refinement_lr=0.001,
+ )
+ with pytest.raises(ValueError, match="velocity_limit is unsupported"):
+ q_mov.prepare_fit(fit_ctx_vlim)
+
+ # Optimizer fail fast for quantum with unsupported parameters
+ x, y = xor_data
+ model = model_factory()
+ loss = nn.BCEWithLogitsLoss()
+
+ with pytest.raises(ValueError, match="negative_swarm is unsupported"):
+ Optimizer(model, loss, task="binary", method="quantum", negative_swarm=0.1)
+
+ with pytest.raises(ValueError, match="mutation_swarm is unsupported"):
+ Optimizer(model, loss, task="binary", method="quantum", mutation_swarm=0.1)
+
+ with pytest.raises(ValueError, match="velocity_limit is unsupported"):
+ Optimizer(model, loss, task="binary", method="quantum", particle_min=-5.0, particle_max=5.0, velocity_limit_ratio=0.1)
+
+ # Repeated fit state reset check
+ opt = Optimizer(model, loss, task="binary", method="quantum", method_options={"beta_min": 0.5, "beta_max": 1.0}, seed=42)
+ res1 = opt.fit(x, y, epochs=3)
+ assert opt.movement_plugin._mbest is not None
+ res2 = opt.fit(x, y, epochs=3)
+ assert len(res2) == 3
+ assert all(math.isfinite(s) for s in res2)
diff --git a/tests/test_post_training_model_convergence.py b/tests/test_post_training_model_convergence.py
new file mode 100644
index 0000000..64914f4
--- /dev/null
+++ b/tests/test_post_training_model_convergence.py
@@ -0,0 +1,330 @@
+"""Behavioral tests for the post-training convergence protocol.
+
+These tests intentionally use tiny local modules and synthetic artifacts. They
+exercise protocol boundaries (rather than implementation details) while
+keeping the production data/model paths completely offline.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import sys
+from pathlib import Path
+
+import pytest
+import torch
+import torch.nn as nn
+
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+import post_training_model_convergence as study
+
+
+class TinyStatefulModel(nn.Module):
+ def __init__(self) -> None:
+ super().__init__()
+ self.feature = nn.Linear(3, 2, bias=False)
+ self.bn = nn.BatchNorm1d(2)
+ self.head = nn.Linear(2, 1)
+
+ def forward(self, value: torch.Tensor) -> torch.Tensor:
+ return self.head(self.bn(self.feature(value)))
+
+
+def _tiny_model() -> TinyStatefulModel:
+ torch.manual_seed(17)
+ model = TinyStatefulModel()
+ model.train()
+ return model
+
+
+@pytest.mark.parametrize(
+ ("field", "value"),
+ [
+ ("protocol_version", "post-training-model-convergence-drift"),
+ ("split_seed", study.SPLIT_SEED + 1),
+ ("base_seeds", (501, 502, 504)),
+ ("swarm_seeds", (601, 602, 604)),
+ ("projection_seed", study.PROJECTION_SEED + 1),
+ ("bootstrap_seed", study.BOOTSTRAP_SEED + 1),
+ ("particle_count", study.PARTICLE_COUNT - 1),
+ ("pso_generations", study.PSO_GENERATIONS - 1),
+ ("residual_dimension", study.RESIDUAL_DIMENSION - 1),
+ ("residual_bound", study.RESIDUAL_BOUND / 2),
+ ("initial_radius", study.INITIAL_RADIUS / 2),
+ ("objective_checkpoints", (0, 1)),
+ ],
+)
+def test_study_config_rejects_protocol_constant_drift(field: str, value: object) -> None:
+ with pytest.raises(study.ProtocolError):
+ study.StudyConfig(**{field: value})
+
+
+def test_study_config_round_trip_and_matrix_order_boundary(tmp_path: Path) -> None:
+ config = study.StudyConfig()
+ assert study.StudyConfig.from_dict(config.to_dict()) == config
+ assert config.base_seeds == (501, 502, 503)
+ assert config.swarm_seeds == (601, 602, 603)
+ assert config.objective_checkpoints == (0, 10, 20, 30, 40, 50, 60)
+ with pytest.raises(study.ProtocolError, match="fixed order"):
+ study._make_adapters(
+ study.StudyConfig(workload_ids=(study.DEFAULT_WORKLOAD_IDS[0],)),
+ tmp_path / "run",
+ tmp_path / "data",
+ False,
+ )
+
+def test_selected_codec_is_deterministic_and_preserves_nonselected_state() -> None:
+ model_a = _tiny_model()
+ model_b = copy.deepcopy(model_a)
+ names = ("feature.weight",)
+ codec_a = study.SelectedResidualCodec(model_a, names, projection_seed=12345)
+ codec_b = study.SelectedResidualCodec(model_b, names, projection_seed=12345)
+ residual = torch.linspace(-0.75, 0.75, study.RESIDUAL_DIMENSION)
+
+ assert codec_a.names == names
+ assert torch.equal(codec_a.projection_indices, codec_b.projection_indices)
+ assert torch.equal(codec_a.decode(residual), codec_b.decode(residual))
+ assert torch.equal(codec_a.decode(torch.zeros(study.RESIDUAL_DIMENSION)), model_a.feature.weight.detach().flatten())
+ assert codec_a.scales == codec_b.scales
+ first_indices = codec_a.projection_indices
+ second_indices = codec_a.projection_indices
+ assert first_indices.data_ptr() != second_indices.data_ptr()
+
+ before = {name: value.detach().clone() for name, value in model_a.named_parameters()}
+ before_buffers = {name: value.detach().clone() for name, value in model_a.named_buffers()}
+ original_modes = {name: child.training for name, child in model_a.named_modules()}
+ with codec_a.applied(model_a, residual):
+ assert not torch.equal(model_a.feature.weight.detach(), before["feature.weight"])
+ assert torch.equal(model_a.head.weight.detach(), before["head.weight"])
+ assert torch.equal(model_a.bn.running_mean, before_buffers["bn.running_mean"])
+ assert model_a.training is False
+ assert {name: child.training for name, child in model_a.named_modules()} == original_modes
+ for name, value in model_a.named_parameters():
+ assert torch.equal(value, before[name])
+ for name, value in model_a.named_buffers():
+ assert torch.equal(value, before_buffers[name])
+
+
+def test_selected_codec_restores_state_after_exception_and_rejects_nonselected_mutation() -> None:
+ model = _tiny_model()
+ codec = study.SelectedResidualCodec(model, ("feature.weight",))
+ before = {name: value.detach().clone() for name, value in model.state_dict().items()}
+
+ with pytest.raises(RuntimeError, match="callback failure"):
+ with codec.applied(model, codec.zero_residual()):
+ model.bn.running_mean.add_(1.0)
+ raise RuntimeError("callback failure")
+ assert all(torch.equal(model.state_dict()[name], value) for name, value in before.items())
+
+ with pytest.raises(study.ProtocolError, match="non-selected"):
+ with codec.applied(model, torch.ones(study.RESIDUAL_DIMENSION)):
+ with torch.no_grad():
+ model.head.bias.add_(1.0)
+ assert all(torch.equal(model.state_dict()[name], value) for name, value in before.items())
+
+
+def test_state_neutral_audit_restores_model_and_rng() -> None:
+ model = _tiny_model()
+ before_state = {name: value.detach().clone() for name, value in model.state_dict().items()}
+ before_modes = {name: child.training for name, child in model.named_modules()}
+ before_rng = torch.get_rng_state().clone()
+
+ def callback() -> float:
+ model.eval()
+ with torch.no_grad():
+ model.feature.weight.add_(3.0)
+ model.bn.running_var.mul_(2.0)
+ torch.manual_seed(999)
+ return 1.25
+
+ assert study.run_state_neutral_audit(model, callback) == 1.25
+ assert {name: child.training for name, child in model.named_modules()} == before_modes
+ assert torch.equal(torch.get_rng_state(), before_rng)
+ assert all(torch.equal(model.state_dict()[name], value) for name, value in before_state.items())
+
+
+def _objective(residual: torch.Tensor) -> study.ObjectiveResult:
+ # Deliberately use every coordinate so a candidate is not a mock echo.
+ return study.ObjectiveResult(
+ loss=float(torch.sum(residual.square()).item()),
+ samples=3,
+ forward_passes=1,
+ backward_passes=1,
+ )
+
+
+def test_pso_and_random_have_exact_equal_query_and_sample_budgets() -> None:
+ validation_calls: list[torch.Tensor] = []
+
+ def validation(residual: torch.Tensor) -> study.AuditResult:
+ validation_calls.append(residual.detach().clone())
+ return study.AuditResult(loss=float(residual.abs().mean()), samples=2)
+
+ pso = study.run_residual_pso(_objective, seed=study.SWARM_SEEDS[0], validation=validation)
+ random = study.run_equal_budget_random(_objective, seed=study.SWARM_SEEDS[0])
+
+ for result in (pso, random):
+ assert result.objective_queries == study.PARTICLE_COUNT * study.PSO_GENERATIONS == 720
+ assert result.counters.objective_samples == 720 * 3
+ assert result.counters.objective_forward_passes == 720
+ assert result.counters.objective_backward_passes == 720
+ assert result.counters.objective_failures == 0
+ assert len(result.endpoints) == study.PSO_GENERATIONS
+ assert len(result.trajectory) == study.PSO_GENERATIONS
+ assert result.best_objective is not None
+ assert result.best_residual is not None
+ assert result.best_residual.shape == (study.RESIDUAL_DIMENSION,)
+
+ assert len(validation_calls) == len(study.OBJECTIVE_CHECKPOINTS)
+ assert pso.counters.validation_evaluations == len(study.OBJECTIVE_CHECKPOINTS)
+ assert pso.counters.validation_samples == len(study.OBJECTIVE_CHECKPOINTS) * 2
+ assert random.method == "feature_random"
+ assert pso.method == "feature_pso"
+
+
+def test_state_machine_and_confirmation_seal_boundaries(tmp_path: Path) -> None:
+ config = study.StudyConfig()
+ state = study.prepare_run(tmp_path, config)
+ with pytest.raises(study.StateTransitionError):
+ state.transition(study.StudyState.FROZEN)
+ state.transition(study.StudyState.DEVELOPING)
+ artifact = tmp_path / "evidence.json"
+ study.atomic_write_json(artifact, {"metric": 1.0})
+
+ manifest = study.freeze_run(tmp_path, config, ["evidence.json"], state)
+ assert state.state is study.StudyState.FROZEN
+ assert study.load_frozen_manifest(tmp_path).manifest_hash == manifest.manifest_hash
+ with pytest.raises(study.StateTransitionError):
+ state.transition(study.StudyState.DEVELOPING)
+
+ study.begin_confirmation(tmp_path, state)
+ assert state.state is study.StudyState.CONFIRMING
+ study.finish_confirmation(state, success=True)
+ assert state.state is study.StudyState.COMPLETED
+ with pytest.raises(study.StateTransitionError):
+ study.finish_confirmation(state, success=True)
+
+
+def test_frozen_manifest_rejects_artifact_hash_drift(tmp_path: Path) -> None:
+ config = study.StudyConfig()
+ state = study.prepare_run(tmp_path, config)
+ state.transition(study.StudyState.DEVELOPING)
+ artifact = tmp_path / "checkpoint.bin"
+ artifact.write_bytes(b"original")
+ study.freeze_run(tmp_path, config, [artifact.name], state)
+ assert study.verify_frozen_manifest(tmp_path).artifacts[artifact.name]
+
+ artifact.write_bytes(b"tampered")
+ with pytest.raises(study.SealError, match="hash mismatch"):
+ study.verify_frozen_manifest(tmp_path)
+
+
+def _completed_record() -> dict[str, float]:
+ return {"loss": 1.0, "queries": 1}
+
+
+def _matrix_result(workload_id: str, artifact_name: str, artifact_hash: str) -> dict[str, object]:
+ cell_tree = {
+ str(base): {str(swarm): _completed_record() for swarm in study.SWARM_SEEDS}
+ for base in study.BASE_SEEDS
+ }
+ return {
+ "workload_id": workload_id,
+ "family": "classification",
+ "config": {},
+ "manifests": {},
+ "provenance": {},
+ "baselines": {str(seed): _completed_record() for seed in study.BASE_SEEDS},
+ "arms": {
+ "feature_pso": cell_tree,
+ "feature_random": copy.deepcopy(cell_tree),
+ "feature_adam": {str(seed): _completed_record() for seed in study.BASE_SEEDS},
+ "head_adam": {str(seed): _completed_record() for seed in study.BASE_SEEDS},
+ },
+ "ensemble": {
+ "uniform": _completed_record(),
+ "uniform_temperature": _completed_record(),
+ "slsqp_weights": _completed_record(),
+ "ensemble_pso": [_completed_record() for _ in study.SWARM_SEEDS],
+ },
+ "development_selection": {},
+ "confirmation": {},
+ "integrity": {"official_test_opened": False},
+ "leakage_counters": {},
+ "resource_ledger": {},
+ "artifact_hashes": {artifact_name: artifact_hash},
+ }
+
+
+def test_strict_matrix_validation_accepts_complete_matrix_and_rejects_missing_cell(tmp_path: Path) -> None:
+ for workload_id in study.DEFAULT_WORKLOAD_IDS:
+ workload_root = tmp_path / "workloads" / workload_id
+ workload_root.mkdir(parents=True)
+ evidence = workload_root / "evidence.bin"
+ evidence.write_bytes(workload_id.encode())
+ relative = str(evidence.relative_to(tmp_path))
+ result = _matrix_result(workload_id, relative, study.fingerprint_file(evidence))
+ (workload_root / "result.json").write_text(json.dumps(result), encoding="utf-8")
+
+ validated = study._validate_matrix_results(tmp_path, strict_development=True)
+ assert set(validated) == set(study.DEFAULT_WORKLOAD_IDS)
+
+ path = tmp_path / "workloads" / study.DEFAULT_WORKLOAD_IDS[0] / "result.json"
+ broken = json.loads(path.read_text(encoding="utf-8"))
+ del broken["arms"]["feature_pso"]["501"]["601"]
+ path.write_text(json.dumps(broken), encoding="utf-8")
+ with pytest.raises(study.SealError, match="feature_pso matrix is incomplete"):
+ study._validate_matrix_results(tmp_path, strict_development=True)
+
+
+def test_development_reuse_requires_complete_hash_verified_artifacts(
+ tmp_path: Path,
+) -> None:
+ workload_root = tmp_path / "workloads" / "synthetic"
+ workload_root.mkdir(parents=True)
+ artifact = workload_root / "evidence.bin"
+ artifact.write_bytes(b"complete")
+ relative = str(artifact.relative_to(tmp_path))
+ result = _matrix_result(
+ "synthetic",
+ relative,
+ study.fingerprint_file(artifact),
+ )
+ (workload_root / "result.json").write_text(
+ json.dumps(result),
+ encoding="utf-8",
+ )
+ (workload_root / "development_reuse.json").write_text(
+ json.dumps(
+ {
+ "protocol_version": study.PROTOCOL_VERSION,
+ "source_run": "failed-but-preserved",
+ }
+ ),
+ encoding="utf-8",
+ )
+
+ class ReusedAdapter:
+ workload_id = "synthetic"
+
+ def run_phase(self, phase: str) -> object:
+ raise AssertionError(f"unexpected phase: {phase}")
+
+ assert study._run_adapter_development(
+ [ReusedAdapter()],
+ tmp_path,
+ ) == [result]
+ artifact.write_bytes(b"drift")
+ with pytest.raises(study.SealError, match="hash drift"):
+ study._run_adapter_development(
+ [ReusedAdapter()],
+ tmp_path,
+ )
diff --git a/tests/test_post_training_pso_ensemble.py b/tests/test_post_training_pso_ensemble.py
new file mode 100644
index 0000000..aa80b5d
--- /dev/null
+++ b/tests/test_post_training_pso_ensemble.py
@@ -0,0 +1,635 @@
+"""
+Unit tests for Post-Training PSO Ensemble Study Runner.
+
+Covers:
+1. Protocol version and module export verification.
+2. CachedProbabilityEnsemble softmax parameterization, forward log-prob normalization, and NLLLoss integration.
+3. Probability cache validation for finite values, non-negativity, and row-sum normalization.
+4. Mixture probabilities for uniform and one-hot weight configurations across PyTorch and NumPy arrays.
+5. Probabilistic metrics computation (accuracy, NLL, Brier, ECE, margin).
+6. Analytical gradient vs central finite-difference gradient verification for simplex NLL.
+7. SLSQP solver optimization success, simplex constraint adherence, and NLL improvement.
+8. Deterministic PSO optimization and exact query/sample accounting on synthetic probability caches.
+9. Development gate boundary checks for safety, accounting, and quality limits.
+10. Production-runner enforcement of the official-test seal on development failure.
+11. Atomic file and CSV report writers.
+"""
+
+import sys
+from pathlib import Path
+
+# Ensure test directory and repo root are in sys.path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+import numpy as np
+import pytest
+import torch
+import torch.nn as nn
+
+import post_training_pso_ensemble as study_module
+
+from post_training_pso_ensemble import (
+ PROTOCOL_VERSION,
+ CachedProbabilityEnsemble,
+ CompactCNN,
+ atomic_write_file,
+ compute_model_fingerprint,
+ evaluate_development_gates,
+ fit_uniform_temperature,
+ mixture_probabilities,
+ optimize_slsqp_weights,
+ probabilistic_metrics,
+ run_pso_weights,
+ save_csv_report,
+ simplex_nll_and_grad,
+ validate_probability_cache,
+)
+
+
+def test_protocol_version():
+ """Verify protocol version identifier adheres to required format."""
+ assert isinstance(PROTOCOL_VERSION, str)
+ assert PROTOCOL_VERSION.startswith("POST-TRAINING-PSO-ENSEMBLE")
+ assert "1.1.0" in PROTOCOL_VERSION or "1.0.0" in PROTOCOL_VERSION
+
+
+def test_cached_probability_ensemble_weights_and_forward():
+ """Verify CachedProbabilityEnsemble parameterization, weight normalization, and log-probability output."""
+ ensemble = CachedProbabilityEnsemble(num_members=5)
+ weights = ensemble.weights()
+
+ assert isinstance(weights, torch.Tensor)
+ assert weights.shape == (5,)
+ assert torch.allclose(weights.sum(), torch.tensor(1.0), atol=1e-6)
+ assert (weights >= 0).all()
+
+ # Custom weight initialization
+ init_w = torch.tensor([2.0, 0.0, 0.0, 0.0, 0.0])
+ ensemble_custom = CachedProbabilityEnsemble(num_members=5, init_weights=init_w)
+ assert torch.allclose(ensemble_custom.raw_weights, init_w)
+
+ # Invalid init shape
+ with pytest.raises(ValueError, match="init_weights must have shape"):
+ CachedProbabilityEnsemble(num_members=5, init_weights=torch.tensor([1.0, 2.0]))
+
+ # CachedProbabilityEnsemble has one canonical input shape: (N, M, K).
+ N, K = 100, 10
+ torch.manual_seed(42)
+ raw_probs = torch.rand(5, N, K)
+ member_probs_mnk = raw_probs / raw_probs.sum(dim=-1, keepdim=True)
+ member_probs_nmk = member_probs_mnk.transpose(0, 1)
+
+ log_probs = ensemble(member_probs_nmk)
+ assert log_probs.shape == (N, K)
+
+ # Verify exponentiated log probabilities sum to 1 per sample.
+ probs = torch.exp(log_probs)
+ assert torch.allclose(probs.sum(dim=-1), torch.ones(N), atol=1e-5)
+
+ # Integration with nn.NLLLoss.
+ targets = torch.randint(0, K, (N,))
+ loss = nn.NLLLoss()(log_probs, targets)
+ assert loss.dim() == 0
+ assert torch.isfinite(loss)
+ assert loss.item() > 0.0
+
+ # Reject the alternate (M, N, K) orientation instead of guessing.
+ with pytest.raises(ValueError, match="canonical"):
+ ensemble(member_probs_mnk)
+
+ # Square N == M caches remain unambiguous because the model always weights
+ # axis 1 and mixture_probabilities always weights axis 0.
+ square_raw = torch.arange(1, 51, dtype=torch.float32).reshape(5, 5, 2)
+ square_mnk = square_raw / square_raw.sum(dim=-1, keepdim=True)
+ raw_logits = torch.tensor([1.5, -0.5, 0.2, 0.8, -1.0])
+ square_ensemble = CachedProbabilityEnsemble(5, init_weights=raw_logits)
+ actual_square = torch.exp(square_ensemble(square_mnk.transpose(0, 1)))
+ expected_square = mixture_probabilities(
+ torch.softmax(raw_logits, dim=0),
+ square_mnk,
+ )
+ assert torch.allclose(actual_square, expected_square, atol=1e-6)
+
+ # Malformed dimension or member count mismatch.
+ with pytest.raises(ValueError):
+ ensemble(torch.rand(N, K))
+ with pytest.raises(ValueError, match="canonical"):
+ ensemble(torch.rand(N, 3, K))
+
+
+def test_validate_probability_cache():
+ """Verify probability cache validation logic for valid, negative, unnormalized, and non-finite cases."""
+ N, K = 50, 10
+ raw = torch.rand(5, N, K)
+ valid_tensor = raw / raw.sum(dim=-1, keepdim=True)
+
+ assert validate_probability_cache(valid_tensor) is True
+ assert validate_probability_cache(valid_tensor.numpy()) is True
+
+ # Negative values
+ invalid_neg = valid_tensor.clone()
+ invalid_neg[0, 0, 0] = -0.05
+ assert validate_probability_cache(invalid_neg) is False
+
+ # Unnormalized (row sum != 1.0)
+ invalid_unnorm = valid_tensor.clone()
+ invalid_unnorm[0, 0, :] *= 0.5
+ assert validate_probability_cache(invalid_unnorm) is False
+
+ # Non-finite values
+ invalid_nan = valid_tensor.clone()
+ invalid_nan[0, 0, 0] = float("nan")
+ assert validate_probability_cache(invalid_nan) is False
+
+
+def test_mixture_probabilities_uniform_and_one_hot():
+ """Verify mixture_probabilities for uniform and one-hot weight configurations."""
+ M, N, K = 5, 40, 10
+ rng = np.random.RandomState(42)
+ raw = rng.rand(M, N, K)
+ member_probs_np = raw / raw.sum(axis=-1, keepdims=True)
+ member_probs_torch = torch.from_numpy(member_probs_np).float()
+
+ # 1. Uniform weights [0.2, 0.2, 0.2, 0.2, 0.2]
+ uniform_w = np.full(M, 0.2)
+ mix_uniform_np = mixture_probabilities(uniform_w, member_probs_np)
+ expected_uniform = member_probs_np.mean(axis=0)
+ assert np.allclose(mix_uniform_np, expected_uniform, atol=1e-6)
+
+ mix_uniform_torch = mixture_probabilities(uniform_w, member_probs_torch)
+ assert torch.allclose(mix_uniform_torch, torch.from_numpy(expected_uniform).float(), atol=1e-5)
+
+ # 2. One-hot weights [1.0, 0.0, 0.0, 0.0, 0.0]
+ onehot_0 = np.array([1.0, 0.0, 0.0, 0.0, 0.0])
+ mix_onehot_0 = mixture_probabilities(onehot_0, member_probs_np)
+ assert np.allclose(mix_onehot_0, member_probs_np[0], atol=1e-6)
+
+ # 3. One-hot weights for model index 2
+ onehot_2 = np.array([0.0, 0.0, 1.0, 0.0, 0.0])
+ mix_onehot_2 = mixture_probabilities(onehot_2, member_probs_np)
+ assert np.allclose(mix_onehot_2, member_probs_np[2], atol=1e-6)
+
+ # Alternate (N, M, K) orientation is rejected rather than guessed.
+ transposed_np = member_probs_np.transpose(1, 0, 2)
+ with pytest.raises(ValueError, match="canonical"):
+ mixture_probabilities(uniform_w, transposed_np)
+
+ # Dimension mismatch
+ with pytest.raises(ValueError):
+ mixture_probabilities(np.array([0.5, 0.5]), member_probs_np)
+
+
+def test_probabilistic_metrics():
+ """Verify calculation of accuracy, NLL, Brier, ECE, and margin metrics."""
+ N, K = 100, 10
+ targets = np.random.RandomState(42).randint(0, K, size=N)
+
+ # Perfect prediction: prob=1.0 at true target index
+ perfect_probs = np.zeros((N, K), dtype=np.float64)
+ perfect_probs[np.arange(N), targets] = 1.0
+
+ metrics_perfect = probabilistic_metrics(perfect_probs, targets)
+ assert metrics_perfect["accuracy"] == 100.0
+ assert metrics_perfect["nll"] < 1e-4
+ assert metrics_perfect["brier"] < 1e-4
+ assert metrics_perfect["ece"] < 1e-4
+ assert metrics_perfect["margin"] == 1.0
+
+ # Uniform prediction (1/K per class)
+ uniform_probs = np.full((N, K), 1.0 / K, dtype=np.float64)
+ metrics_uniform = probabilistic_metrics(uniform_probs, targets)
+ expected_nll = -np.log(1.0 / K)
+ assert np.isclose(metrics_uniform["nll"], expected_nll, atol=1e-3)
+ assert metrics_uniform["margin"] == 0.0
+
+
+def test_simplex_nll_and_grad_vs_finite_difference():
+ """Verify analytical simplex NLL gradient against central finite differences."""
+ M, N, K = 5, 200, 10
+ rng = np.random.RandomState(101)
+ raw = rng.rand(M, N, K)
+ member_probs = raw / raw.sum(axis=-1, keepdims=True)
+ targets = rng.randint(0, K, size=N)
+
+ weights = np.array([0.3, 0.2, 0.1, 0.25, 0.15], dtype=np.float64)
+ nll_analytical, grad_analytical = simplex_nll_and_grad(weights, member_probs, targets)
+
+ assert np.isfinite(nll_analytical)
+ assert grad_analytical.shape == (M,)
+ assert np.all(np.isfinite(grad_analytical))
+
+ # Numerical gradient computation via central finite differences
+ h = 1e-6
+ grad_numerical = np.zeros(M, dtype=np.float64)
+ for i in range(M):
+ w_plus = weights.copy()
+ w_plus[i] += h
+ nll_plus, _ = simplex_nll_and_grad(w_plus, member_probs, targets)
+
+ w_minus = weights.copy()
+ w_minus[i] -= h
+ nll_minus, _ = simplex_nll_and_grad(w_minus, member_probs, targets)
+
+ grad_numerical[i] = (nll_plus - nll_minus) / (2.0 * h)
+
+ assert np.allclose(grad_analytical, grad_numerical, atol=1e-4)
+
+
+def test_optimize_slsqp_weights():
+ """Verify SLSQP solver optimization success, simplex adherence, and NLL non-regression."""
+ M, N, K = 5, 300, 10
+ rng = np.random.RandomState(202)
+ raw = rng.rand(M, N, K)
+ member_probs = raw / raw.sum(axis=-1, keepdims=True)
+ targets = rng.randint(0, K, size=N)
+
+ # Make member 0 slightly better to give SLSQP a clear target
+ member_probs[0, np.arange(N), targets] += 0.5
+ member_probs = member_probs / member_probs.sum(axis=-1, keepdims=True)
+
+ result = optimize_slsqp_weights(member_probs, targets)
+
+ assert result["success"] is True
+ assert len(result["weights"]) == M
+ weights = np.array(result["weights"])
+ assert np.all(weights >= 0.0)
+ assert np.isclose(weights.sum(), 1.0, atol=1e-6)
+
+ # Verify optimized NLL is no worse than uniform ensemble NLL
+ uniform_p = mixture_probabilities(np.full(M, 1.0 / M), member_probs)
+ uniform_nll = probabilistic_metrics(uniform_p, targets)["nll"]
+ assert result["metrics"]["nll"] <= uniform_nll + 1e-6
+ assert result["evaluations"] > 0
+ assert result["wall_time_seconds"] >= 0.0
+
+
+def test_run_pso_weights_determinism_and_accounting():
+ """Verify PSO weight optimization determinism, exact accounting, and output structure."""
+ M, N, K = 5, 100, 10
+ rng = np.random.RandomState(303)
+ raw = rng.rand(M, N, K)
+ member_probs = raw / raw.sum(axis=-1, keepdims=True)
+ targets = rng.randint(0, K, size=N)
+
+ swarm_seeds = [301, 302]
+ res_1 = run_pso_weights(member_probs, targets, swarm_seeds=swarm_seeds, device="cpu")
+
+ # Accounting verification
+ assert res_1["queries_per_seed"] == 900
+ assert res_1["sample_evaluations_per_seed"] == 900 * N
+ assert res_1["total_queries"] == 900 * len(swarm_seeds)
+ assert res_1["total_sample_evaluations"] == 900 * N * len(swarm_seeds)
+
+ per_seed = res_1["per_seed_runs"]
+ assert len(per_seed) == len(swarm_seeds)
+ for run_rec in per_seed:
+ assert run_rec["queries"] == 900
+ assert run_rec["sample_evaluations"] == 900 * N
+ assert np.isclose(sum(run_rec["weights"]), 1.0, atol=1e-5)
+ assert run_rec["wall_time_seconds"] >= 0.0
+
+ # Repeatability / Determinism check
+ res_2 = run_pso_weights(member_probs, targets, swarm_seeds=swarm_seeds, device="cpu")
+ assert res_1["selected_seed"] == res_2["selected_seed"]
+ assert np.allclose(res_1["selected_weights"], res_2["selected_weights"], atol=1e-5)
+ assert np.isclose(
+ res_1["per_seed_runs"][0]["metrics"]["nll"],
+ res_2["per_seed_runs"][0]["metrics"]["nll"],
+ atol=1e-5,
+ )
+
+
+
+
+def test_evaluate_development_gates_pass_and_boundary_failures():
+ """Verify development gate boundary evaluations across passing and failing synthetic workloads."""
+ def make_valid_workload(seed_nll=1.5, pso_nll=1.0, pso_acc=90.0, slsqp_nll=1.0):
+ def make_mets(nll_val, acc_val):
+ return {"accuracy": acc_val, "nll": nll_val, "brier": 0.15, "ece": 0.02, "margin": 0.5}
+
+ return {
+ "provenance": {"dataset_name": "mnist"},
+ "training": {"adam_pool_wall_time_seconds": 100.0},
+ "validation_cache": {
+ "pool_forward_passes": 5,
+ "base_cnn_forward_passes_during_optimization": 0,
+ },
+ "official_test_data_loaded_before_freeze": False,
+ "official_test_evaluations_before_freeze": 0,
+ "validation": {
+ "methods": {
+ "reference_single_10e": make_mets(seed_nll, 80.0),
+ "best_single_10e": make_mets(1.4, 82.0),
+ "single_50e": make_mets(1.1, 88.0),
+ "uniform_ensemble": make_mets(1.05, 89.9),
+ "uniform_temperature": {
+ "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ "metrics": make_mets(1.04, 90.0),
+ },
+ "slsqp_weights": {
+ "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ "success": True,
+ "metrics": make_mets(slsqp_nll, 90.0),
+ },
+ "pso_weights": {
+ "selected_seed": 301,
+ "selected_weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ "metrics": make_mets(pso_nll, pso_acc),
+ "median_one_seed_wall_time_seconds": 2.0,
+ "per_seed_runs": [
+ {
+ "seed": 301,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "metrics": make_mets(pso_nll, pso_acc),
+ "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ },
+ {
+ "seed": 302,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "metrics": make_mets(pso_nll + 0.01, pso_acc),
+ "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ },
+ {
+ "seed": 303,
+ "queries": 900,
+ "sample_evaluations": 9000000,
+ "metrics": make_mets(pso_nll + 0.02, pso_acc),
+ "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ },
+ ],
+ },
+ }
+ },
+ }
+
+ valid_workloads = {
+ "mnist": make_valid_workload(),
+ "fashion_mnist": make_valid_workload(),
+ }
+
+ eval_pass = evaluate_development_gates(valid_workloads)
+ assert eval_pass["pass"] is True
+ assert eval_pass["failed_hard_gate_count"] == 0
+ assert len(eval_pass["gate_results"]) == 13
+
+ # Assert exact expected gate names
+ expected_gate_names = {
+ "all_values_finite",
+ "validation_pool_forward_passes_exact",
+ "optimization_base_model_forward_passes",
+ "official_test_data_loaded_before_freeze",
+ "slsqp_solver_success",
+ "query_and_sample_accounting_exact",
+ "maximum_pso_nll_regression_vs_uniform",
+ "maximum_pso_accuracy_regression_vs_uniform_pp",
+ "pso_nll_below_reference_single",
+ "maximum_pso_nll_regression_vs_equal_budget_single",
+ "maximum_relative_pso_nll_gap_vs_slsqp",
+ "cross_dataset_mean_relative_pso_nll_reduction_vs_uniform_minimum",
+ "maximum_median_one_seed_pso_to_pool_training_wall_ratio",
+ }
+ assert set(eval_pass["gate_results"].keys()) == expected_gate_names
+
+ # 1. Test data loaded before freeze failure
+ leak_workloads = {
+ "mnist": make_valid_workload(),
+ "fashion_mnist": make_valid_workload(),
+ }
+ leak_workloads["mnist"]["official_test_data_loaded_before_freeze"] = True
+ assert evaluate_development_gates(leak_workloads)["pass"] is False
+
+ # 2. PSO accuracy regression > 0.1 pp below uniform
+ acc_fail_workloads = {
+ "mnist": make_valid_workload(pso_acc=89.0), # Uniform is 89.9
+ "fashion_mnist": make_valid_workload(),
+ }
+ assert evaluate_development_gates(acc_fail_workloads)["pass"] is False
+
+ # 3. Base model called during optimization
+ base_call_fail_workloads = {
+ "mnist": make_valid_workload(),
+ "fashion_mnist": make_valid_workload(),
+ }
+ base_call_fail_workloads["mnist"]["validation_cache"][
+ "base_cnn_forward_passes_during_optimization"
+ ] = 1
+ assert evaluate_development_gates(base_call_fail_workloads)["pass"] is False
+
+
+def test_global_test_seal_monkeypatch(monkeypatch, tmp_path):
+ """A failed production development run must never construct train=False data."""
+ import torchvision.datasets
+
+ official_constructor_calls = []
+
+ def guarded_dataset(*args, **kwargs):
+ train = kwargs.get("train", True)
+ official_constructor_calls.append(train)
+ if train is False:
+ raise RuntimeError("Leakage blocked: train=False requested before pass")
+ raise AssertionError("Synthetic split setup must bypass train=True constructors")
+
+ monkeypatch.setattr(torchvision.datasets, "MNIST", guarded_dataset)
+ monkeypatch.setattr(torchvision.datasets, "FashionMNIST", guarded_dataset)
+
+ class TinyCNN(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.logits = nn.Parameter(torch.zeros(10))
+
+ def forward(self, x):
+ return self.logits.unsqueeze(0).expand(len(x), -1)
+
+ def fake_prepare(dataset_name, split_seed, cache_dir):
+ x = torch.zeros(1, 1, 28, 28)
+ y = torch.zeros(1, dtype=torch.long)
+ return x, y, x.clone(), y.clone(), {
+ "dataset_name": dataset_name,
+ "split_seed": split_seed,
+ "search_samples": 1,
+ "validation_samples": 1,
+ "normalization": {"mean": 0.0, "std": 1.0},
+ "data_fingerprint": "synthetic",
+ "split_fingerprint": "synthetic",
+ }
+
+ def fake_probabilities(model, x_data, device, batch_size=1000):
+ with torch.no_grad():
+ return torch.softmax(model(x_data.to(device)), dim=1).cpu(), 0.0
+
+ def fake_temperature(uniform_probs, targets):
+ metrics = probabilistic_metrics(uniform_probs, targets)
+ return 1.0, {
+ "fitted_temperature": 1.0,
+ "wall_time_seconds": 0.0,
+ "evaluations": 1,
+ "metrics": metrics,
+ }
+
+ def fake_slsqp(member_probabilities, targets):
+ weights = [0.2] * 5
+ metrics = probabilistic_metrics(
+ mixture_probabilities(weights, member_probabilities),
+ targets,
+ )
+ return {
+ "weights": weights,
+ "evaluations": 1,
+ "wall_time_seconds": 0.0,
+ "success": True,
+ "message": "synthetic",
+ "metrics": metrics,
+ }
+
+ def fake_pso(
+ member_probabilities,
+ targets,
+ swarm_seeds,
+ particles,
+ epochs,
+ device,
+ ):
+ weights = [0.2] * 5
+ metrics = probabilistic_metrics(
+ mixture_probabilities(weights, member_probabilities),
+ targets,
+ )
+ queries = particles * epochs
+ samples = queries * len(targets)
+ runs = [
+ {
+ "seed": seed,
+ "queries": queries,
+ "sample_evaluations": samples,
+ "wall_time_seconds": 0.0,
+ "metrics": metrics,
+ "weights": weights,
+ }
+ for seed in swarm_seeds
+ ]
+ return {
+ "per_seed_runs": runs,
+ "selected_seed": swarm_seeds[0],
+ "selected_weights": weights,
+ "metrics": metrics,
+ "queries_per_seed": queries,
+ "sample_evaluations_per_seed": samples,
+ "total_queries": queries * len(swarm_seeds),
+ "total_sample_evaluations": samples * len(swarm_seeds),
+ "median_one_seed_wall_time_seconds": 0.0,
+ "total_wall_time_seconds": 0.0,
+ }
+
+ monkeypatch.setattr(study_module, "CompactCNN", TinyCNN)
+ monkeypatch.setattr(study_module, "prepare_dataset_splits", fake_prepare)
+ monkeypatch.setattr(study_module, "get_model_probabilities", fake_probabilities)
+ monkeypatch.setattr(study_module, "fit_uniform_temperature", fake_temperature)
+ monkeypatch.setattr(study_module, "optimize_slsqp_weights", fake_slsqp)
+ monkeypatch.setattr(study_module, "run_pso_weights", fake_pso)
+ monkeypatch.setattr(
+ study_module,
+ "evaluate_development_gates",
+ lambda workloads: {
+ "pass": False,
+ "failed_hard_gate_count": 1,
+ "gate_results": {"synthetic_failure": False},
+ "issues": ["forced development failure"],
+ },
+ )
+ monkeypatch.setattr(study_module, "save_csv_report", lambda *args: None)
+ monkeypatch.setattr(study_module, "save_publication_plot", lambda *args: None)
+
+ artifact = study_module.run_post_training_study(
+ cache_dir=tmp_path / "cache",
+ device="cpu",
+ output_json=tmp_path / "study.json",
+ output_csv=tmp_path / "study.csv",
+ output_png=tmp_path / "study.png",
+ )
+
+ assert artifact["development_pass"] is False
+ assert artifact["official_test_data_loaded"] is False
+ assert all(
+ workload["confirmation"] is None
+ for workload in artifact["workloads"].values()
+ )
+ assert official_constructor_calls == []
+
+
+def test_atomic_writers(tmp_path):
+ """Verify atomic writing and CSV output formatting."""
+ target_file = tmp_path / "report.csv"
+ content = "header1,header2\nval1,val2\n"
+
+ atomic_write_file(target_file, content)
+ assert target_file.exists()
+ assert target_file.read_text() == content
+
+ # Test overwrite
+ new_content = "header1,header2\nval3,val4\n"
+ atomic_write_file(target_file, new_content)
+ assert target_file.read_text() == new_content
+
+ # Synthetic artifact CSV generation
+ def make_mets(acc, nll):
+ return {"accuracy": acc, "nll": nll, "brier": 0.15, "ece": 0.02, "margin": 0.5}
+
+ artifact = {
+ "protocol_version": PROTOCOL_VERSION,
+ "policy_frozen": True,
+ "development_pass": True,
+ "official_test_data_loaded": True,
+ "resource_totals": {
+ "total_pso_queries": 5400,
+ "total_pso_sample_evaluations": 54000000,
+ "total_pso_wall_time_seconds": 12.5,
+ },
+ "workloads": {
+ "mnist": {
+ "validation": {
+ "methods": {
+ "reference_single_10e": make_mets(85.0, 0.50),
+ "best_single_10e": make_mets(87.0, 0.45),
+ "single_50e": make_mets(89.0, 0.40),
+ "uniform_ensemble": make_mets(89.9, 0.36),
+ "uniform_temperature": {
+ "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ "metrics": make_mets(90.0, 0.355),
+ },
+ "slsqp_weights": {
+ "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ "wall_time_seconds": 0.5,
+ "metrics": make_mets(90.0, 0.35),
+ },
+ "pso_weights": {
+ "selected_seed": 301,
+ "selected_weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ "metrics": make_mets(92.5, 0.25),
+ "median_one_seed_wall_time_seconds": 2.0,
+ "per_seed_runs": [
+ {
+ "seed": 301,
+ "metrics": make_mets(92.5, 0.25),
+ "weights": [0.2, 0.2, 0.2, 0.2, 0.2],
+ }
+ ],
+ },
+ }
+ }
+ }
+ },
+ }
+
+ csv_path = tmp_path / "summary.csv"
+ save_csv_report(artifact, csv_path)
+ assert csv_path.exists()
+ lines = csv_path.read_text().splitlines()
+ assert len(lines) >= 2
+ assert "Workload,Phase,Method" in lines[0]
diff --git a/tests/test_post_training_resnet_convergence.py b/tests/test_post_training_resnet_convergence.py
new file mode 100644
index 0000000..1094ebe
--- /dev/null
+++ b/tests/test_post_training_resnet_convergence.py
@@ -0,0 +1,242 @@
+"""Behavioral tests for the offline CIFAR/ResNet convergence adapter."""
+
+from __future__ import annotations
+
+import builtins
+import copy
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+from test import post_training_resnet_convergence as resnet # noqa: E402
+from test.post_training_model_convergence import ( # noqa: E402
+ CandidateEndpoint,
+ ObjectiveResult,
+ ProtocolError,
+ SelectedResidualCodec,
+ StudyConfig,
+ prepare_run,
+ select_endpoint,
+)
+
+
+class _TinyBlock(nn.Module):
+ def __init__(self, channels: int = 2) -> None:
+ super().__init__()
+ self.conv = nn.Conv2d(channels, channels, kernel_size=1)
+ self.bn = nn.BatchNorm2d(channels)
+
+ def forward(self, value: torch.Tensor) -> torch.Tensor:
+ return F.relu(self.bn(self.conv(value)))
+
+
+class _TinyResNet(nn.Module):
+ """Small module with the same prefix/layer4/suffix contract as ResNet."""
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.conv1 = nn.Conv2d(3, 2, kernel_size=3, padding=1, bias=False)
+ self.bn1 = nn.BatchNorm2d(2)
+ self.relu = nn.ReLU()
+ self.maxpool = nn.Identity()
+ self.layer1 = nn.Sequential(_TinyBlock())
+ self.layer2 = nn.Sequential(_TinyBlock())
+ self.layer3 = nn.Sequential(_TinyBlock())
+ self.layer4 = nn.Sequential(_TinyBlock(), _TinyBlock())
+ self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+ self.fc = nn.Linear(2, 3)
+ def forward(self, value: torch.Tensor) -> torch.Tensor:
+ value = self.maxpool(self.relu(self.bn1(self.conv1(value))))
+ value = self.layer1(value)
+ value = self.layer2(value)
+ value = self.layer3(value)
+ value = self.layer4(value)
+ return self.fc(torch.flatten(self.avgpool(value), 1))
+
+
+def _synthetic_cifar() -> tuple[np.ndarray, np.ndarray, tuple[int, int]]:
+ """Make valid-shaped, deterministic pixels without constructing a dataset."""
+ count = resnet.TRAIN_SAMPLES
+ labels = np.repeat(np.arange(10, dtype=np.int64), count // 10)
+ images = np.zeros((count, 32, 32, 3), dtype=np.uint8)
+ encoded = np.arange(count, dtype=np.uint32).view(np.uint8).reshape(count, 4)
+ images[:, 0, 0, :] = encoded[:, :3]
+ rng = np.random.default_rng(20260908)
+ initial_assignment = np.full(count, "", dtype=object)
+ for cls in range(10):
+ members = np.flatnonzero(labels == cls)
+ members = members[rng.permutation(len(members))]
+ initial_assignment[members[:3500]] = "bp_train"
+ initial_assignment[members[3500:4000]] = "refine_search"
+ initial_assignment[members[4000:5000]] = "selection_val"
+ first = 0
+ second = next(
+ index
+ for index in range(1, count // 10)
+ if initial_assignment[index] != initial_assignment[first]
+ )
+ images[second] = images[first]
+ return images, labels, (first, second)
+
+
+def test_cifar_manifest_is_deterministic_disjoint_and_group_safe() -> None:
+ images, labels, duplicate_pair = _synthetic_cifar()
+ first = resnet.build_cifar_manifests(images, labels, split_seed=20260908)
+ second = resnet.build_cifar_manifests(images, labels, split_seed=20260908)
+
+ assert first == second
+ roles = first["roles"]
+ role_sets = {role: set(indices) for role, indices in roles.items()}
+ assert sum(len(indices) for indices in role_sets.values()) == len(labels)
+ for role, values in role_sets.items():
+ for other, other_values in role_sets.items():
+ if role != other:
+ assert values.isdisjoint(other_values)
+ assert set().union(*role_sets.values()) == set(range(len(labels)))
+
+ owner_roles = [role for role, values in role_sets.items() if duplicate_pair[0] in values]
+ assert len(owner_roles) == 1
+ assert duplicate_pair[1] in role_sets[owner_roles[0]]
+ assert set(first["objective"]).issubset(role_sets["refine_search"])
+ assert len(first["objective"]) == resnet.OBJECTIVE_SAMPLES
+ assert len(set(first["objective"])) == resnet.OBJECTIVE_SAMPLES
+ objective_labels = labels[np.asarray(first["objective"])]
+ assert np.bincount(objective_labels, minlength=10).tolist() == [103, 103, 103, 103, 102, 102, 102, 102, 102, 102]
+ assert first["normalization_scope"] == "bp_train_only"
+
+
+def test_real_resnet_selected_suffix_topology_without_downloads() -> None:
+ try:
+ import torchvision # noqa: F401
+ except Exception as exc: # torchvision is optional on lightweight CI workers.
+ pytest.skip(f"torchvision unavailable: {exc}")
+
+ for architecture, block in (("resnet18", "layer4.1"), ("resnet50", "layer4.2")):
+ model = resnet.make_cifar_resnet(architecture, seed=501)
+ assert model.conv1.in_channels == 3
+ assert model.conv1.out_channels == 64
+ assert model.conv1.kernel_size == (3, 3)
+ assert model.conv1.stride == (1, 1)
+ assert isinstance(model.maxpool, nn.Identity)
+
+ names = resnet.selected_parameter_names(model, architecture)
+ expected = tuple(
+ name
+ for name, parameter in model.named_parameters()
+ if name.startswith(block + ".") and parameter.is_floating_point()
+ )
+ assert names == expected
+ assert names and all(name.startswith(block + ".") for name in names)
+ assert resnet.head_parameter_names(model) == ("fc.weight", "fc.bias")
+
+
+def test_cached_suffix_parity_and_residual_zero_nonzero_restoration() -> None:
+ torch.manual_seed(7)
+ model = _TinyResNet()
+ images = torch.randn(5, 3, 8, 8)
+ labels = torch.tensor([0, 1, 2, 1, 0])
+ model.eval()
+ cache = resnet.ResNetCache.build(model, images, labels, block_index=1, batch_size=2)
+ names = tuple(name for name, _ in model.named_parameters() if name.startswith("layer4.1."))
+ codec = SelectedResidualCodec(model, names, projection_seed=resnet.PROJECTION_SEED)
+ zero = codec.zero_residual()
+ nonzero = torch.full((codec.dimension,), 0.4)
+
+ base_state = {name: value.detach().clone() for name, value in model.state_dict().items()}
+ base_logits = resnet.CachedSuffixEvaluator(model, cache, "cpu").logits()
+ assert torch.equal(codec.decode(zero), torch.cat([value.reshape(-1) for value in codec.base_values]))
+ assert torch.count_nonzero(codec.decode_delta(zero)) == 0
+ assert torch.count_nonzero(codec.decode_delta(nonzero)) > 0
+
+ with codec.applied(model, zero):
+ assert torch.equal(resnet.CachedSuffixEvaluator(model, cache, "cpu").logits(), base_logits)
+ assert all(torch.equal(value, base_state[name]) for name, value in model.state_dict().items())
+
+ model.train()
+ with pytest.raises(RuntimeError, match="candidate failure"):
+ with codec.applied(model, nonzero):
+ selected = dict(model.named_parameters())
+ assert any(not torch.equal(selected[name], base_state[name]) for name in names)
+ assert all(torch.equal(selected[name], base_state[name]) for name in selected if name not in names)
+ assert all(torch.equal(value, base_state[name]) for name, value in model.named_buffers())
+ raise RuntimeError("candidate failure")
+ assert model.training
+ assert all(torch.equal(value, base_state[name]) for name, value in model.state_dict().items())
+
+ parity = resnet.cached_residual_parity(model, images, cache, codec, nonzero)
+ assert parity["passed"] is True
+ assert parity["samples"] == len(images)
+ assert parity["max_abs_difference"] <= 1e-6
+ assert resnet.cached_full_parity(model, images, cache)["passed"] is True
+
+
+
+def test_endpoint_selection_ties_are_stable() -> None:
+ objective = ObjectiveResult(loss=0.25, samples=4)
+ endpoints = (
+ CandidateEndpoint(20, 1, torch.ones(64), objective),
+ CandidateEndpoint(10, 0, torch.zeros(64), objective),
+ )
+ assert select_endpoint(endpoints, {10: 0.5, 20: 0.5}).generation == 10
+ assert select_endpoint(endpoints, {10: 0.8, 20: 0.8}, maximize=True).generation == 10
+ with pytest.raises(ProtocolError):
+ select_endpoint(endpoints, {10: float("nan"), 20: 0.5})
+
+
+def test_ensemble_fit_uses_objective_pool_and_apply_does_not_refit() -> None:
+ pytest.importorskip("scipy")
+ rng = np.random.default_rng(19)
+ objective_probs = rng.uniform(0.01, 1.0, size=(3, 9, 3))
+ objective_probs /= objective_probs.sum(axis=-1, keepdims=True)
+ selection_probs = np.roll(objective_probs, shift=1, axis=1).copy()
+ objective_labels = np.arange(9, dtype=np.int64) % 3
+ selection_labels = np.roll(objective_labels, 2)
+
+ fitted = resnet.run_ensemble_methods(objective_probs, objective_labels, swarm_seeds=(601,))
+ fitted_snapshot = copy.deepcopy(fitted)
+ applied = resnet.evaluate_fitted_ensemble(fitted, selection_probs, selection_labels)
+ assert fitted == fitted_snapshot
+
+ uniform = np.full(3, 1 / 3)
+ expected_uniform = np.einsum("m,mnk->nk", uniform, selection_probs)
+ expected_nll = float(-np.log(np.clip(expected_uniform[np.arange(9), selection_labels], 1e-300, 1.0)).mean())
+ assert applied["uniform"]["metrics"]["nll"] == pytest.approx(expected_nll, abs=1e-12)
+ assert fitted["uniform"]["metrics"]["nll"] == pytest.approx(
+ float(-np.log(np.clip(np.einsum("m,mnk->nk", uniform, objective_probs)[np.arange(9), objective_labels], 1e-300, 1.0)).mean()),
+ abs=1e-12,
+ )
+
+ for candidate in applied["ensemble_pso"]:
+ weights = np.asarray(candidate["weights"], dtype=np.float64)
+ mixed = np.einsum("m,mnk->nk", weights, selection_probs)
+ expected = float(-np.log(np.clip(mixed[np.arange(9), selection_labels], 1e-300, 1.0)).mean())
+ assert candidate["selection_metrics"]["nll"] == pytest.approx(expected, abs=1e-12)
+
+
+def test_official_test_loader_refuses_pre_freeze_without_importing_dataset(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ run_root = tmp_path / "run"
+ prepare_run(run_root, StudyConfig())
+ imported = False
+ original_import = builtins.__import__
+
+ def reject_torchvision(name: str, *args: object, **kwargs: object):
+ nonlocal imported
+ if name.startswith("torchvision"):
+ imported = True
+ raise AssertionError("official dataset import must be behind the frozen seal")
+ return original_import(name, *args, **kwargs)
+
+ monkeypatch.setattr(builtins, "__import__", reject_torchvision)
+ with pytest.raises(resnet.TestSealError, match="forbidden before frozen"):
+ resnet.load_official_test_data(tmp_path / "data", run_root, allow_download=False)
+ assert imported is False
diff --git a/tests/test_post_training_yolo_convergence.py b/tests/test_post_training_yolo_convergence.py
new file mode 100644
index 0000000..272f4fd
--- /dev/null
+++ b/tests/test_post_training_yolo_convergence.py
@@ -0,0 +1,331 @@
+"""Offline behavioral tests for the pinned VOC/YOLO convergence adapter."""
+
+from __future__ import annotations
+
+import builtins
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+import torch
+from torch import nn
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+from test import post_training_yolo_convergence as study
+from test.post_training_model_convergence import SealError, StudyConfig, prepare_run
+
+
+def _record(index: int, *, fingerprint: str | None = None) -> study.VOCRecord:
+ """Build a cheap, label-complete synthetic record for manifest tests."""
+ labels = tuple((class_id, 0.5, 0.5, 0.25, 0.25) for class_id in range(20))
+ return study.VOCRecord(
+ year="2007" if index % 2 == 0 else "2012",
+ image_id=f"item-{index:05d}",
+ image_path=f"/synthetic/{index}.jpg",
+ annotation_path=f"/synthetic/{index}.xml",
+ width=640,
+ height=480,
+ labels=labels,
+ difficult_excluded=0,
+ fingerprint=fingerprint or f"{index:064x}",
+ )
+
+
+def test_optional_detection_imports_are_lazy(monkeypatch: pytest.MonkeyPatch) -> None:
+ """Importing the adapter stays safe when optional detection packages are absent."""
+ real_import = builtins.__import__
+
+ def block_ultralytics(name, *args, **kwargs):
+ if name == "ultralytics":
+ raise ImportError("blocked optional dependency")
+ return real_import(name, *args, **kwargs)
+
+ monkeypatch.setattr(builtins, "__import__", block_ultralytics)
+ with pytest.raises(study.YoloProtocolError, match="Ultralytics is required"):
+ study._ultralytics()
+
+ def block_ensemble_boxes(name, *args, **kwargs):
+ if name == "ensemble_boxes":
+ raise ImportError("blocked optional dependency")
+ return real_import(name, *args, **kwargs)
+
+ monkeypatch.setattr(builtins, "__import__", block_ensemble_boxes)
+ with pytest.raises(study.YoloProtocolError, match="ensemble-boxes is required"):
+ study._wbf()
+
+
+def test_parse_voc_xml_excludes_difficult_and_uses_pinned_coordinates(tmp_path: Path) -> None:
+ Image = pytest.importorskip("PIL.Image")
+ image_path = tmp_path / "sample.jpg"
+ Image.new("RGB", (20, 20), (10, 20, 30)).save(image_path)
+ xml_path = tmp_path / "sample.xml"
+ xml_path.write_text(
+ """
+ 20203
+
+
+ """,
+ encoding="utf-8",
+ )
+
+ record = study.parse_voc_xml(xml_path, image_path, year="2007", image_id="sample")
+
+ assert record.width == 20 and record.height == 20
+ assert record.difficult_excluded == 1
+ assert record.labels == ((7, 0.2, 0.25, 0.4, 0.4),)
+ assert record.fingerprint == study.image_fingerprint(image_path)
+
+
+def test_duplicate_grouping_keeps_group_members_together() -> None:
+ duplicate_a = _record(0, fingerprint="same")
+ duplicate_b = _record(1, fingerprint="same")
+ unique = _record(2, fingerprint="unique")
+
+ ordered, groups = study._assign_duplicate_groups(
+ [duplicate_a, duplicate_b, unique], seed=20260908
+ )
+
+ assert groups["same"] == tuple(f"{item.year}:{item.image_id}" for item in ordered if item.fingerprint == "same")
+ same_positions = [index for index, item in enumerate(ordered) if item.fingerprint == "same"]
+ assert same_positions == list(range(min(same_positions), max(same_positions) + 1))
+ assert {item.image_id for item in ordered} == {"item-00000", "item-00001", "item-00002"}
+
+
+def test_manifest_has_exact_disjoint_partitions_and_objective_prefix() -> None:
+ records = [_record(index) for index in range(16551)]
+ manifest = study.make_voc_manifests(records, seed=20260908)
+
+ assert manifest.counts == {
+ "bp_train": study.BP_COUNT,
+ "refine_search": study.REFINE_COUNT,
+ "selection_val": study.SELECTION_COUNT,
+ }
+ partitions = (manifest.bp_train, manifest.refine_search, manifest.selection_val)
+ keys = [
+ {f"{item.year}:{item.image_id}" for item in partition}
+ for partition in partitions
+ ]
+ assert [len(partition) for partition in partitions] == [11551, 2500, 2500]
+ assert not (keys[0] & keys[1] or keys[0] & keys[2] or keys[1] & keys[2])
+ assert manifest.objective_keys == tuple(
+ (item.year, item.image_id) for item in manifest.refine_search[: study.OBJECTIVE_COUNT]
+ )
+ for partition in partitions:
+ assert {label[0] for item in partition for label in item.labels} == set(range(20))
+
+
+def test_letterbox_box_round_trip_preserves_original_coordinates() -> None:
+ original = np.array([[10.0, 5.0, 190.0, 95.0, 0.87]], dtype=np.float64)
+ ratio_pad = (3.2, (0.0, 160.0)) # 200x100 image letterboxed to 640x640
+
+ letterboxed = study.transform_boxes_to_letterbox(original, ratio_pad=ratio_pad)
+ restored = study.transform_boxes_to_original(
+ letterboxed, ratio_pad=ratio_pad, shape=(100, 200)
+ )
+
+ assert np.allclose(restored, original, atol=1e-12)
+ assert np.allclose(letterboxed[0, :4], [32.0, 176.0, 608.0, 464.0])
+ clipped = study.transform_boxes_to_original(
+ np.array([[-10.0, 150.0, 650.0, 500.0]]),
+ ratio_pad=ratio_pad,
+ shape=(100, 200),
+ )
+ assert np.array_equal(clipped, np.array([[0.0, 0.0, 200.0, 100.0]]))
+
+def test_native_target_uses_non_square_letterbox_geometry() -> None:
+ record = study.VOCRecord(
+ year="2007",
+ image_id="wide",
+ image_path="/synthetic/wide.jpg",
+ annotation_path="/synthetic/wide.xml",
+ width=200,
+ height=100,
+ labels=((0, 0.5, 0.5, 0.5, 0.5),),
+ difficult_excluded=0,
+ fingerprint="a" * 64,
+ )
+ target = study._native_target(
+ record,
+ index=3,
+ ratio_pad=(3.2, (0.0, 160.0)),
+ )
+ assert target["batch_idx"].tolist() == [3]
+ assert target["cls"].tolist() == [[0.0]]
+ assert np.allclose(
+ target["bboxes"].numpy(),
+ np.array([[0.5, 0.5, 0.5, 0.25]]),
+ )
+
+
+def test_wbf_uses_normalized_weights_and_stable_score_order(monkeypatch: pytest.MonkeyPatch) -> None:
+ captured: dict[str, object] = {}
+
+ def fake_fusion(boxes, scores, labels, **kwargs):
+ captured["weights"] = kwargs["weights"]
+ captured["kwargs"] = kwargs
+ return (
+ [[0.1, 0.1, 0.2, 0.2], [0.3, 0.3, 0.4, 0.4], [0.5, 0.5, 0.6, 0.6]],
+ [0.20, 0.90, 0.50],
+ [2, 1, 0],
+ )
+
+ monkeypatch.setattr(study, "_wbf", lambda: fake_fusion)
+ result = study.weighted_box_fusion(
+ [
+ {"boxes": np.array([[0.1, 0.1, 0.2, 0.2]]), "scores": [0.8], "labels": [2]},
+ {"boxes": np.array([[0.3, 0.3, 0.4, 0.4]]), "scores": [0.7], "labels": [1]},
+ ],
+ [2.0, 6.0],
+ )
+
+ assert captured["weights"] == pytest.approx([0.25, 0.75])
+ assert sum(captured["weights"]) == pytest.approx(1.0)
+ assert captured["kwargs"]["iou_thr"] == 0.55
+ assert result["scores"].tolist() == [0.90, 0.50, 0.20]
+ assert result["labels"].tolist() == [1, 0, 2]
+
+
+def test_wbf_pso_and_random_have_exact_12x20_query_accounting(monkeypatch: pytest.MonkeyPatch) -> None:
+ calls: list[tuple[float, ...]] = []
+
+ def tiny_metric(member_predictions, targets, weights):
+ values = tuple(float(value) for value in weights)
+ calls.append(values)
+ assert sum(values) == pytest.approx(1.0)
+ return {"map50_95": values[0]}
+
+ monkeypatch.setattr(study, "_wbf_dataset_metrics", tiny_metric)
+ targets = [{"image_id": "a"}, {"image_id": "b"}]
+ members = [[{} for _ in targets] for _ in range(3)]
+
+ pso = study.run_wbf_weight_search(members, targets, seed=601, random_mode=False)
+ random_result = study.run_wbf_weight_search(members, targets, seed=601, random_mode=True)
+
+ assert pso["method"] == "ensemble_pso"
+ assert random_result["method"] == "ensemble_random"
+ for result in (pso, random_result):
+ assert result["queries"] == 12 * 20
+ assert result["sample_evaluations"] == 12 * 20 * len(targets)
+ assert len(result["trajectory"]) == 20
+ assert sum(result["weights"]) == pytest.approx(1.0)
+ assert all(0.0 <= weight <= 1.0 for weight in result["weights"])
+ assert len(calls) == 2 * 12 * 20
+
+
+class C3k2(nn.Module):
+ pass
+
+
+class Detect(nn.Module):
+ def __init__(self, nc: int = 20) -> None:
+ super().__init__()
+ self.nc = nc
+ self.cv2 = nn.ModuleList([nn.Sequential(nn.Linear(1, 42)) for _ in range(3)])
+ self.cv3 = nn.ModuleList([nn.Sequential(nn.Linear(1, 42)) for _ in range(3)])
+
+
+class WrongDetect(Detect):
+ pass
+
+
+class WrongBlock(nn.Module):
+ pass
+
+
+def _tiny_graph(*, block: nn.Module | None = None, detect: nn.Module | None = None) -> nn.Module:
+ graph = nn.Module()
+ graph.model = nn.ModuleList([nn.Identity() for _ in range(22)] + [block or C3k2(), detect or Detect()])
+ return graph
+
+
+@pytest.mark.parametrize(
+ ("graph", "message"),
+ [
+ (nn.Module(), "shorter than"),
+ (_tiny_graph(block=WrongBlock()), "expected model.22 C3k2"),
+ (_tiny_graph(detect=WrongDetect()), "expected model.23 Detect"),
+ (_tiny_graph(detect=Detect(nc=19)), "expected Detect.nc=20"),
+ ],
+)
+def test_topology_guard_rejects_tiny_mismatched_graphs(graph: nn.Module, message: str) -> None:
+ if not hasattr(graph, "model"):
+ graph.model = nn.ModuleList([nn.Identity(), nn.Identity()])
+ with pytest.raises(study.YoloProtocolError, match=message):
+ study.assert_yolo_topology(graph)
+
+
+def test_official_test_loader_refuses_before_frozen_confirmation(tmp_path: Path) -> None:
+ run_root = tmp_path / "run"
+ data_root = tmp_path / "data"
+ state = prepare_run(run_root, StudyConfig(device="cpu"))
+
+ with pytest.raises(SealError, match="sealed until confirm phase"):
+ study.guarded_voc_test_loader(data_root, run_root, confirmation=False)
+ assert state.state.value == "prepared"
+ assert not (data_root / "VOCdevkit").exists()
+
+ with pytest.raises(SealError, match="sealed until frozen confirmation"):
+ study.VOCTestGuard(str(run_root), "", False).require_open()
+
+
+def test_native_baseline_reuse_verifies_complete_epoch_artifacts(
+ tmp_path: Path,
+) -> None:
+ run_root = tmp_path / "run"
+ baseline_root = (
+ run_root
+ / "workloads"
+ / study.WORKLOAD_ID
+ / "baselines"
+ / "501"
+ )
+ baseline_root.mkdir(parents=True)
+ checkpoint = baseline_root / "ema_fp32.pt"
+ torch.save({"weight": torch.ones(2)}, checkpoint)
+ results = (
+ run_root
+ / "ultralytics"
+ / "base-501-100e"
+ / "results.csv"
+ )
+ results.parent.mkdir(parents=True)
+ results.write_text(
+ "epoch,train/loss\n"
+ + "".join(f"{epoch},{1 / epoch}\n" for epoch in range(1, 101)),
+ encoding="utf-8",
+ )
+ marker = {
+ "protocol_version": study.PROTOCOL_VERSION,
+ "source_run": "source",
+ "checkpoint_hash": study.fingerprint_file(checkpoint),
+ "results_hash": study.fingerprint_file(results),
+ }
+ (baseline_root / "baseline_reuse.json").write_text(
+ json.dumps(marker),
+ encoding="utf-8",
+ )
+
+ reused = study._reused_native_baseline(
+ run_root,
+ study.StrictScratchTrainer(device="cpu"),
+ 501,
+ )
+ assert reused is not None
+ assert reused["reused"] is True
+ assert len(reused["telemetry"]) == 11
+ results.write_text("epoch,train/loss\n1,1\n", encoding="utf-8")
+ with pytest.raises(study.YoloProtocolError, match="reused baseline marker"):
+ study._reused_native_baseline(
+ run_root,
+ study.StrictScratchTrainer(device="cpu"),
+ 501,
+ )
diff --git a/tests/test_public_api.py b/tests/test_public_api.py
new file mode 100644
index 0000000..081ccc1
--- /dev/null
+++ b/tests/test_public_api.py
@@ -0,0 +1,180 @@
+import inspect
+import subprocess
+import sys
+import pytest
+import torch
+import pso
+from pso import Optimizer, Particle, __version__
+
+
+def test_canonical_exports_and_all():
+ """Verify pso exports Optimizer, Particle, __version__, stage plugins and defines __all__ correctly."""
+ expected_all = [
+ "Optimizer",
+ "Particle",
+ "__version__",
+ "BasePlugin",
+ "InitializationPlugin",
+ "EvaluationPlugin",
+ "MovementPlugin",
+ "ConvergencePlugin",
+ "RefinementPlugin",
+ "PluginMetadata",
+ "SwarmState",
+ "available_plugins",
+ ]
+ assert pso.__all__ == expected_all
+ assert pso.Optimizer is Optimizer
+ assert pso.Particle is Particle
+ assert pso.__version__ == "4.0.0"
+ assert __version__ == "4.0.0"
+
+ from pso.plugins import (
+ BasePlugin,
+ InitializationPlugin,
+ EvaluationPlugin,
+ MovementPlugin,
+ ConvergencePlugin,
+ RefinementPlugin,
+ PluginMetadata,
+ SwarmState,
+ available_plugins,
+ )
+ assert pso.BasePlugin is BasePlugin
+ assert pso.InitializationPlugin is InitializationPlugin
+ assert pso.EvaluationPlugin is EvaluationPlugin
+ assert pso.MovementPlugin is MovementPlugin
+ assert pso.ConvergencePlugin is ConvergencePlugin
+ assert pso.RefinementPlugin is RefinementPlugin
+ assert pso.PluginMetadata is PluginMetadata
+ assert pso.SwarmState is SwarmState
+ assert pso.available_plugins is available_plugins
+
+
+def test_lowercase_aliases_and_legacy_api_absent():
+ """Verify lowercase names and legacy get_best_weights are excluded/absent."""
+ assert "optimizer" not in pso.__all__
+ assert "particle" not in pso.__all__
+ assert not hasattr(Optimizer, "get_best_weights")
+ assert hasattr(Optimizer, "get_best_state_dict")
+
+ if hasattr(pso, "optimizer"):
+ obj = getattr(pso, "optimizer")
+ assert not isinstance(obj, type)
+
+ if hasattr(pso, "particle"):
+ obj = getattr(pso, "particle")
+ assert not isinstance(obj, type)
+
+
+def test_optimizer_init_signature_and_kwonly():
+ """Verify Optimizer.__init__ parameter names and keyword-only positions."""
+ sig = inspect.signature(Optimizer.__init__)
+ params = sig.parameters
+
+ assert "model" in params
+ assert "loss" in params
+
+ # Positional parameters (excluding self)
+ assert params["model"].kind in (
+ inspect.Parameter.POSITIONAL_OR_KEYWORD,
+ inspect.Parameter.POSITIONAL_ONLY,
+ )
+ assert params["loss"].kind in (
+ inspect.Parameter.POSITIONAL_OR_KEYWORD,
+ inspect.Parameter.POSITIONAL_ONLY,
+ )
+
+ kwonly_expected = [
+ "method",
+ "initialization",
+ "evaluation",
+ "convergence",
+ "refinement",
+ "method_options",
+ "n_particles",
+ "c0",
+ "c1",
+ "w_min",
+ "w_max",
+ "negative_swarm",
+ "mutation_swarm",
+ "particle_min",
+ "particle_max",
+ "velocity_limit_ratio",
+ "boundary_strategy",
+ "initial_position_noise",
+ "seed",
+ "device",
+ "fitness_size",
+ "convergence_patience",
+ "convergence_min_delta",
+ "convergence_monitor",
+ "refinement_epochs",
+ "refinement_lr",
+ "moment_blend",
+ "moment_beta1",
+ "moment_beta2",
+ "moment_step_size",
+ "moment_epsilon",
+ ]
+
+ for name in kwonly_expected:
+ assert name in params, f"Missing parameter {name} in Optimizer.__init__"
+ assert params[name].kind == inspect.Parameter.KEYWORD_ONLY, (
+ f"Parameter {name} must be KEYWORD_ONLY"
+ )
+
+
+def test_optimizer_fit_signature_and_kwonly():
+ """Verify Optimizer.fit parameter names and keyword-only positions."""
+ sig = inspect.signature(Optimizer.fit)
+ params = sig.parameters
+
+ assert "x" in params
+ assert "y" in params
+
+ kwonly_expected = [
+ "epochs",
+ "batch_size",
+ "fitness_size",
+ "renewal",
+ "validation_data",
+ "validation_split",
+ "output_dir",
+ "log_format",
+ "checkpoint_interval",
+ "save_info",
+ ]
+
+ for name in kwonly_expected:
+ assert name in params, f"Missing parameter {name} in Optimizer.fit"
+ assert params[name].kind == inspect.Parameter.KEYWORD_ONLY, (
+ f"Parameter {name} must be KEYWORD_ONLY"
+ )
+
+
+def test_kwonly_positional_and_unknown_kwargs(model_factory, xor_data):
+ """Verify passing keyword-only arguments positionally or unknown kwargs raises TypeError."""
+ x, y = xor_data
+ model = model_factory()
+ loss = torch.nn.BCEWithLogitsLoss()
+
+ with pytest.raises(TypeError):
+ Optimizer(model, loss, "binary") # type: ignore[call-arg]
+
+ opt = Optimizer(model, loss, task="binary")
+ with pytest.raises(TypeError):
+ opt.fit(x, y, invalid_unknown_arg=123) # type: ignore[call-arg]
+
+
+def test_subprocess_import_quiet_stdout():
+ """Verify importing pso in a fresh subprocess produces exit code 0 and empty stdout."""
+ res = subprocess.run(
+ [sys.executable, "-c", "import pso"],
+ capture_output=True,
+ text=True,
+ check=False,
+ )
+ assert res.returncode == 0, f"Import failed with stderr: {res.stderr}"
+ assert res.stdout == "", f"Expected empty stdout from import pso, got: {res.stdout!r}"
diff --git a/tests/test_publish_heavy_cross_split.py b/tests/test_publish_heavy_cross_split.py
new file mode 100644
index 0000000..23824ff
--- /dev/null
+++ b/tests/test_publish_heavy_cross_split.py
@@ -0,0 +1,400 @@
+"""
+Unit tests for Heavy PSO Cross-Split Results Publisher.
+
+Covers:
+1. Valid publication pipeline execution on synthetic 9-variant cross-split source data.
+2. Verification of compact JSON schema, cumulative resources (432 runs, 414720 queries, 4147200000 samples),
+ official test seals (0 evaluations), confirmation_executed=false, retained_policy=null.
+3. Verification of exact CSV output shape (72 data rows) and deterministic byte-for-byte reproducibility.
+4. Validation error enforcement for cell count mismatch, official test unsealing, unexpected development pass,
+ and variant count mismatch.
+5. CLI entrypoint invocation.
+"""
+
+import csv
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+# Ensure test directory and repo root are in sys.path
+REPO_ROOT = Path(__file__).resolve().parent.parent if Path(__file__).resolve().parent.name != "PSO" else Path(__file__).resolve().parent
+TEST_DIR = REPO_ROOT / "test"
+if str(TEST_DIR) not in sys.path:
+ sys.path.insert(0, str(TEST_DIR))
+if str(REPO_ROOT) not in sys.path:
+ sys.path.insert(0, str(REPO_ROOT))
+
+import publish_heavy_cross_split as publisher
+from pso import __version__ as pso_version
+
+
+def make_synthetic_source(
+ source_path: Path,
+ num_variants: int = 9,
+ cell_count: int = 8,
+ test_evals: int = 0,
+ test_loaded: bool = False,
+ dev_pass: bool = False,
+ queries_per_run: int = 960,
+ samples_per_run: int = 9600000,
+) -> Path:
+ """
+ Creates a synthetic cross-split experiment run directory with candidates/ and evaluations/
+ matching expected structure for testing publisher integrity checks.
+ """
+ cand_dir = source_path / "candidates"
+ eval_dir = source_path / "evaluations"
+ cand_dir.mkdir(parents=True, exist_ok=True)
+ eval_dir.mkdir(parents=True, exist_ok=True)
+
+ splits = [20260905, 20260906]
+ workloads = ["mnist_compact", "mnist_wide", "fashion_compact", "fashion_wide"]
+ swarm_seeds = [101, 102, 103]
+
+ for variant_id in publisher.EXPECTED_VARIANT_IDS[:num_variants]:
+ cf_path = cand_dir / f"{variant_id}.json"
+ ef_path = eval_dir / f"{variant_id}.json"
+
+ # Construct Candidate Artifact
+ splits_dict = {}
+ for split_seed in splits:
+ split_key = str(split_seed)
+ baselines_dict = {}
+ candidates_dict = {}
+
+ for wl in workloads:
+ baseline_method = "G8" if "compact" in wl else "G5"
+
+ def make_runs():
+ runs_list = []
+ for seed in swarm_seeds:
+ runs_list.append({
+ "seed": seed,
+ "val_selected_loss": 0.50,
+ "val_selected_acc": 80.0,
+ "gbest_loss": 0.48,
+ "gbest_acc": 81.0,
+ "wall_time_sec": 0.01,
+ "optimization_wall_time_sec": 0.01,
+ "validation_wall_time_sec": 0.001,
+ "throughput_samples_per_sec": 1000000.0,
+ "total_queries": queries_per_run,
+ "total_sample_evaluations": samples_per_run,
+ "official_test_evaluations": test_evals,
+ "val_metrics": {"brier": 0.1, "ece": 0.02},
+ "is_finite": True,
+ "core_swarm_state_bytes": 1000,
+ })
+ return runs_list
+
+ baselines_dict[wl] = {
+ "workload_id": wl,
+ "method_id": baseline_method,
+ "subset_size": 10000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": swarm_seeds,
+ "split_seed": split_seed,
+ "data_fingerprint": f"data-fp-{wl}-{split_seed}",
+ "split_fingerprint": f"split-fp-{wl}-{split_seed}",
+ "per_seed_runs": make_runs(),
+ }
+ candidates_dict[wl] = {
+ "workload_id": wl,
+ "ratio": 0.5,
+ "subset_size": 10000,
+ "particles": 12,
+ "epochs": 80,
+ "seeds": swarm_seeds,
+ "split_seed": split_seed,
+ "data_fingerprint": f"data-fp-{wl}-{split_seed}",
+ "split_fingerprint": f"split-fp-{wl}-{split_seed}",
+ "per_seed_runs": make_runs(),
+ }
+
+ splits_dict[split_key] = {
+ "split_seed": split_seed,
+ "baselines": baselines_dict,
+ "candidates": candidates_dict,
+ }
+
+ candidate_payload = {
+ "version": "HEAVY-PSO-CROSS-SPLIT 1.0.0",
+ "protocol_version": "HEAVY-PSO-CROSS-SPLIT 1.0.0",
+ "phase": "development",
+ "split_seeds": splits,
+ "swarm_seeds": swarm_seeds,
+ "official_test_data_loaded": test_loaded,
+ "official_test_evaluations": test_evals * 48,
+ "candidate_config": {
+ "ratio": 0.5,
+ "geometry_policy": "baseline_aligned",
+ "particles": 12,
+ "epochs": 80,
+ "subset_size": 10000,
+ },
+ "workloads": {wl: {"workload_id": wl, "baseline_method": "G8" if "compact" in wl else "G5"} for wl in workloads},
+ "splits": splits_dict,
+ "resource_totals": {
+ "total_runs": 48,
+ "total_queries": queries_per_run * 48,
+ "total_samples_evaluated": samples_per_run * 48,
+ "official_test_evaluations": test_evals * 48,
+ "wall_time_sec": 1.0,
+ },
+ }
+
+ # Construct Evaluation Artifact
+ cell_metrics = []
+ for s_idx, split_seed in enumerate(splits):
+ for wl in workloads:
+ cell_metrics.append({
+ "phase": "development",
+ "split_seed": split_seed,
+ "workload_id": wl,
+ "baseline_acc": 80.0,
+ "candidate_acc": 80.5,
+ "baseline_nll": 0.50,
+ "candidate_nll": 0.49,
+ "acc_gain_pp": 0.5,
+ "nll_reduction_fraction": 0.02,
+ })
+
+ cell_metrics = cell_metrics[:cell_count]
+
+ evaluation_payload = {
+ "pass": False,
+ "development_pass": dev_pass,
+ "eligible_for_confirmation": False,
+ "score": -300.0 + publisher.EXPECTED_VARIANT_IDS.index(variant_id) * 10.0,
+ "evaluator_version": "HEAVY-PSO-CROSS-SPLIT-EVALUATOR 1.0.0",
+ "failed_hard_gate_count": 3,
+ "failed_gates": ["maximum_accuracy_regression_percentage_points_each_split_workload"],
+ "gates": {
+ "official_test_sealed": {
+ "pass": not test_loaded and test_evals == 0,
+ }
+ },
+ "summary_metrics": {
+ "development_cells": len(cell_metrics),
+ "development_grand_mean_accuracy_gain_pp": 0.5,
+ "development_grand_mean_nll_reduction_fraction": 0.02,
+ "development_mnist_wide_accuracy_gain_pp": -0.5,
+ "development_mnist_wide_nll_reduction_fraction": -0.01,
+ },
+ "state_ratios": {
+ "development": {
+ "mnist_compact": 0.4918032786885246,
+ "mnist_wide": 0.5,
+ "fashion_compact": 0.4918032786885246,
+ "fashion_wide": 0.5,
+ }
+ },
+ "cell_metrics": cell_metrics,
+ }
+
+ with cf_path.open("w", encoding="utf-8") as f:
+ json.dump(candidate_payload, f, indent=2)
+ with ef_path.open("w", encoding="utf-8") as f:
+ json.dump(evaluation_payload, f, indent=2)
+
+ return source_path
+
+
+def test_publish_synthetic_success(tmp_path):
+ """Verifies successful end-to-end publication on valid synthetic 9-variant cross-split source data."""
+ source_dir = make_synthetic_source(tmp_path / "source")
+ out_json = tmp_path / "pso_v7_heavy_cross_split.json"
+ out_csv = tmp_path / "pso_v7_heavy_cross_split.csv"
+ out_plot = tmp_path / "pso_v7_heavy_cross_split.png"
+
+ payload = publisher.publish_heavy_cross_split(
+ source_dir=source_dir,
+ output_json=out_json,
+ output_csv=out_csv,
+ output_plot=out_plot,
+ )
+
+ # 1. JSON Verification
+ assert out_json.is_file()
+ assert payload["protocol_version"] == publisher.PUBLISH_PROTOCOL_VERSION
+ assert payload["pso_version"] == pso_version
+ assert payload["official_test_data_loaded"] is False
+ assert payload["official_test_evaluations"] == 0
+ assert payload["confirmation_executed"] is False
+ assert payload["retained_policy"] is None
+
+ assert payload["total_runs"] == 432
+ assert payload["total_queries"] == 414720
+ assert payload["total_sample_evaluations"] == 4147200000
+ assert payload["total_wall_time_sec"] == 9.0
+ assert len(payload["variants"]) == 9
+ assert payload["verdict"]["status"] == "NO_RETAINED_POLICY_NO_CONFIRMATION"
+
+ # Best-observed variant should be the final expected variant.
+ best_v = [v for v in payload["variants"] if v["is_best_observed"]]
+ assert len(best_v) == 1
+ assert best_v[0]["variant_id"] == publisher.EXPECTED_VARIANT_IDS[-1]
+
+ # 2. CSV Verification
+ assert out_csv.is_file()
+ with out_csv.open("r", encoding="utf-8") as f:
+ reader = list(csv.reader(f))
+ # 1 header line + 72 data rows = 73 lines
+ assert len(reader) == 73
+ header = reader[0]
+ assert "variant_id" in header
+ assert "baseline_acc" in header
+ assert "candidate_acc" in header
+ assert "acc_gain_pp" in header
+
+ # 3. Plot Verification
+ assert out_plot.is_file()
+ assert out_plot.stat().st_size > 0
+
+
+def test_publish_mismatch_cell_count(tmp_path):
+ """Verifies ValueError when an evaluation artifact has a cell count other than 8."""
+ source_dir = make_synthetic_source(tmp_path / "source", cell_count=7)
+ out_json = tmp_path / "out.json"
+ out_csv = tmp_path / "out.csv"
+ out_plot = tmp_path / "out.png"
+
+ with pytest.raises(ValueError, match="Expected 8 development cells"):
+ publisher.publish_heavy_cross_split(source_dir, out_json, out_csv, out_plot)
+
+
+def test_publish_official_test_unsealed(tmp_path):
+ """Verifies ValueError when official test evaluations > 0 or official_test_data_loaded is True."""
+ source_dir = make_synthetic_source(tmp_path / "source", test_evals=10)
+ out_json = tmp_path / "out.json"
+ out_csv = tmp_path / "out.csv"
+ out_plot = tmp_path / "out.png"
+
+ with pytest.raises(ValueError, match="official_test_evaluations must be 0"):
+ publisher.publish_heavy_cross_split(source_dir, out_json, out_csv, out_plot)
+
+
+def test_publish_unexpected_pass(tmp_path):
+ """Verifies ValueError when development_pass is True."""
+ source_dir = make_synthetic_source(tmp_path / "source", dev_pass=True)
+ out_json = tmp_path / "out.json"
+ out_csv = tmp_path / "out.csv"
+ out_plot = tmp_path / "out.png"
+
+ with pytest.raises(ValueError, match="development_pass must be False"):
+ publisher.publish_heavy_cross_split(source_dir, out_json, out_csv, out_plot)
+
+
+def test_publish_variant_count_mismatch(tmp_path):
+ """Verifies that omitting an expected variant is rejected."""
+ source_dir = make_synthetic_source(tmp_path / "source", num_variants=8)
+ out_json = tmp_path / "out.json"
+ out_csv = tmp_path / "out.csv"
+ out_plot = tmp_path / "out.png"
+
+ with pytest.raises(ValueError, match="Expected exact development variants"):
+ publisher.publish_heavy_cross_split(source_dir, out_json, out_csv, out_plot)
+
+
+def test_deterministic_csv_shape(tmp_path):
+ """Verifies that running publication twice yields identical CSV byte content."""
+ source_dir = make_synthetic_source(tmp_path / "source")
+ out_json = tmp_path / "out.json"
+ out_csv1 = tmp_path / "out1.csv"
+ out_csv2 = tmp_path / "out2.csv"
+ out_plot = tmp_path / "out.png"
+
+ publisher.publish_heavy_cross_split(source_dir, out_json, out_csv1, out_plot)
+ publisher.publish_heavy_cross_split(source_dir, out_json, out_csv2, out_plot)
+
+ assert out_csv1.read_bytes() == out_csv2.read_bytes()
+
+def test_publish_rejects_wrong_variant_identity(tmp_path):
+ source_dir = make_synthetic_source(tmp_path / "source")
+ candidate = source_dir / "candidates" / f"{publisher.EXPECTED_VARIANT_IDS[-1]}.json"
+ evaluation = source_dir / "evaluations" / f"{publisher.EXPECTED_VARIANT_IDS[-1]}.json"
+ candidate.rename(candidate.with_name("iteration-9999-development.json"))
+ evaluation.rename(evaluation.with_name("iteration-9999-development.json"))
+
+ with pytest.raises(ValueError, match="Expected exact development variants"):
+ publisher.publish_heavy_cross_split(
+ source_dir,
+ tmp_path / "out.json",
+ tmp_path / "out.csv",
+ tmp_path / "out.png",
+ )
+
+
+def test_publish_rejects_resource_total_mismatch(tmp_path):
+ source_dir = make_synthetic_source(tmp_path / "source")
+ candidate = source_dir / "candidates" / f"{publisher.EXPECTED_VARIANT_IDS[0]}.json"
+ payload = json.loads(candidate.read_text(encoding="utf-8"))
+ payload["resource_totals"]["total_queries"] -= 1
+ candidate.write_text(json.dumps(payload), encoding="utf-8")
+
+ with pytest.raises(ValueError, match=r"resource_totals\.total_queries"):
+ publisher.publish_heavy_cross_split(
+ source_dir,
+ tmp_path / "out.json",
+ tmp_path / "out.csv",
+ tmp_path / "out.png",
+ )
+
+
+def test_publish_rejects_invalid_wall_time(tmp_path):
+ source_dir = make_synthetic_source(tmp_path / "source")
+ candidate = source_dir / "candidates" / f"{publisher.EXPECTED_VARIANT_IDS[0]}.json"
+ candidate_payload = json.loads(candidate.read_text(encoding="utf-8"))
+ candidate_payload["resource_totals"]["wall_time_sec"] = float("nan")
+ candidate.write_text(json.dumps(candidate_payload), encoding="utf-8")
+
+ with pytest.raises(ValueError, match=r"resource_totals\.wall_time_sec"):
+ publisher.publish_heavy_cross_split(
+ source_dir,
+ tmp_path / "out.json",
+ tmp_path / "out.csv",
+ tmp_path / "out.png",
+ )
+
+
+def test_publish_uses_repository_relative_source_path(tmp_path, monkeypatch):
+ monkeypatch.setattr(publisher, "REPO_ROOT", tmp_path)
+ source_dir = make_synthetic_source(tmp_path / "source")
+ csv_path = tmp_path / "out.csv"
+ payload = publisher.publish_heavy_cross_split(
+ source_dir,
+ tmp_path / "out.json",
+ csv_path,
+ tmp_path / "out.png",
+ )
+ assert payload["source_provenance"]["source_dir"] == "source"
+ with csv_path.open(encoding="utf-8") as handle:
+ rows = list(csv.DictReader(handle))
+ assert rows[0]["candidate_path"].startswith("source/candidates/")
+ assert rows[0]["evaluation_path"].startswith("source/evaluations/")
+
+
+def test_cli_invocation(tmp_path, monkeypatch):
+ """Verifies CLI main entrypoint executes cleanly."""
+ source_dir = make_synthetic_source(tmp_path / "source")
+ out_json = tmp_path / "cli.json"
+ out_csv = tmp_path / "cli.csv"
+ out_plot = tmp_path / "cli.png"
+
+ cli_args = [
+ "publish_heavy_cross_split.py",
+ "--source-dir", str(source_dir),
+ "--output-json", str(out_json),
+ "--output-csv", str(out_csv),
+ "--output-plot", str(out_plot),
+ ]
+ monkeypatch.setattr(sys, "argv", cli_args)
+
+ publisher.main()
+
+ assert out_json.is_file()
+ assert out_csv.is_file()
+ assert out_plot.is_file()
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..7cad5f5
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,1970 @@
+version = 1
+revision = 3
+requires-python = ">=3.10, <3.12"
+resolution-markers = [
+ "python_full_version >= '3.11' and sys_platform == 'win32'",
+ "python_full_version >= '3.11' and sys_platform == 'emscripten'",
+ "python_full_version >= '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version >= '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version >= '3.11' and sys_platform == 'darwin'",
+ "python_full_version < '3.11' and sys_platform == 'win32'",
+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version < '3.11' and sys_platform == 'darwin'",
+]
+
+[[package]]
+name = "absl-py"
+version = "2.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/4f/d79676ab82f2e42fc3611618139f13a9c4c31d0cff4b486982047679a802/absl_py-2.5.0.tar.gz", hash = "sha256:0c996f25c0490700fadabe6351630f6111534fa0ae252cc6d2014ea3b141135f", size = 118119, upload-time = "2026-07-03T10:57:48.157Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/58/0a/a10b45aab35b175aded078a462dc8d0c698f5b13946e7cb0869097b78bb6/absl_py-2.5.0-py3-none-any.whl", hash = "sha256:0f17b89f2a4eaaedc4f28c622998aa690564b3012a396a4ffad0821007fe03ba", size = 137410, upload-time = "2026-07-03T10:57:46.735Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.15.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "idna", marker = "python_full_version >= '3.11'" },
+ { name = "typing-extensions", marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" },
+]
+
+[[package]]
+name = "backports-tarfile"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/86/72/cd9b395f25e290e633655a100af28cb253e4393396264a98bd5f5951d50f/backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991", size = 86406, upload-time = "2024-05-28T17:01:54.731Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", size = 30181, upload-time = "2024-05-28T17:01:53.112Z" },
+]
+
+[[package]]
+name = "build"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "(os_name == 'nt' and platform_machine != 'aarch64' and sys_platform == 'linux') or (os_name == 'nt' and sys_platform != 'darwin' and sys_platform != 'linux')" },
+ { name = "importlib-metadata", marker = "python_full_version < '3.10.2'" },
+ { name = "packaging" },
+ { name = "pyproject-hooks" },
+ { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4d/b7/1db48a9ce2984842c8c886432ec8a2719613322e868a966ba82a28862f25/build-1.6.0.tar.gz", hash = "sha256:bd2c8afc603e7a2e0ce70e2ea85f0a6d02043bafbd307f5bada0f98669eca5af", size = 113825, upload-time = "2026-08-27T21:01:16.458Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ab/e5/aa1e81b21aea0ce0ba435311837a37d4cb936e7461f9fecac08580073ba9/build-1.6.0-py3-none-any.whl", hash = "sha256:f7aaf1ebbb79178a02ba248bb524f2176b256017e17e8e4bd4289c7b38cc2bad", size = 31187, upload-time = "2026-08-27T21:01:14.957Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.7.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "pycparser", marker = "(python_full_version < '3.11' and implementation_name != 'PyPy' and sys_platform == 'emscripten') or (implementation_name != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/17/0b/ba385d8ccedf926c3cd06e8e2f327027da5afe5f0eb30f1f7bc43ac55125/cffi-2.1.1-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:42e2f76b9455f5a9a844f770bf3e200ed3da0e15f5df3db9c31fe80b04b3d004", size = 211037, upload-time = "2026-08-03T21:19:17.705Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/b9/0f2e58b2cefa33255bff36935d42b13180fe559bba82596540eb404bde7d/cffi-2.1.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5a59cc1c4442bc3d5c703bf720b51138d0bfc173618807c9ee2490a7541dd3d9", size = 218652, upload-time = "2026-08-03T21:19:18.735Z" },
+ { url = "https://files.pythonhosted.org/packages/75/77/60bebf6f818bec84210ac5b6979ce4eeadce6fbbaabc9c7ab23e506d1ce5/cffi-2.1.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:194cffa889098ced9976c3fc6340305e43f6303657d298da55366907c05c22d6", size = 218742, upload-time = "2026-08-03T21:19:22.523Z" },
+ { url = "https://files.pythonhosted.org/packages/b0/ae/679bf47e73fd77b352171727f07de559a003f14de5d02b904a6ec1fa73ca/cffi-2.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5bb4e7ea95dcd6a014a6fef62e62467d67d8e582326443f3d68e71d6320a9fcf", size = 221054, upload-time = "2026-08-03T21:19:23.694Z" },
+ { url = "https://files.pythonhosted.org/packages/09/b8/eefc0e06913b70aa153bf74c946094a18f58fd4aff11b7f372bfdfdca050/cffi-2.1.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3d22a20b1fb1632cc72c22f95f7b0d2961c3e1c235f245ba4c606c4771035659", size = 213489, upload-time = "2026-08-03T21:19:24.922Z" },
+ { url = "https://files.pythonhosted.org/packages/6f/13/4e56852824a03cdf68523a35686f1c28eacd4bd30a7b0a78e682e6e6e1d3/cffi-2.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:1dea0e4d7d4f11f619fe8c1d76caf49e24405b4b5743c0e3be16a500ecd930c9", size = 220241, upload-time = "2026-08-03T21:19:26.214Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/5a/4707a0dc1f203f5dde5a907b0d4e3c25d71120241048bd5bc6f1bb9d4e71/cffi-2.1.1-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0", size = 211805, upload-time = "2026-08-03T21:19:31.867Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/66/c19feabb28485b6e0bbaaafa90837a1ef5d302e90f2178bd33f17a49879b/cffi-2.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813", size = 218716, upload-time = "2026-08-03T21:19:32.896Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/a4/4399daaf8f7dfee9d7c3327fdb0426ee041cc63edc358b93911ceb2bfc7a/cffi-2.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632", size = 217807, upload-time = "2026-08-03T21:19:36.286Z" },
+ { url = "https://files.pythonhosted.org/packages/28/f7/dabe6da2466ecbd82dc62e7342dc6b1065dad990c06f00f0ede9ebf2a0ed/cffi-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd", size = 221252, upload-time = "2026-08-03T21:19:37.416Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/87/616202d8e51342c07d2534c510111c4cc37201775ce8f60802c9335d1edd/cffi-2.1.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a", size = 214214, upload-time = "2026-08-03T21:19:38.507Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/c6/ab025d75d2c26c19b087c0124e75ee31cb65032f4fe345d356d8c507ab97/cffi-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa", size = 219408, upload-time = "2026-08-03T21:19:39.809Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/71/aa/554e2614f38fc34c58ff1d0911ae8535ad2516440d5482d76fe59f1088b0/charset_normalizer-3.5.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1ee1e296209fdce05b81b663250eefa02213a2da7b41bf26f7829b8ba3545aa", size = 369072, upload-time = "2026-08-15T08:16:22.964Z" },
+ { url = "https://files.pythonhosted.org/packages/03/6d/439231dfc3ccfa6f8c06477b7da2219cbd41a2de3d49084df8ec7b5100f2/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9fbdce1e47394b09bc9f26ab117dfc8d6491977a11d86f592bb42c779db2fda", size = 251142, upload-time = "2026-08-15T08:16:24.81Z" },
+ { url = "https://files.pythonhosted.org/packages/55/53/7d819bd23a00ef45039146fa2cce1daa2f0771e758c5653ee1f6edac91ed/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:00668ebb0609751758682eb0b5857e7c35b9f00e84dfdef062e103244ec94d45", size = 240714, upload-time = "2026-08-15T08:16:26.392Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/2c/45847198c16f4b38090cc7423b2b6a9008e438704d8ab413211832498d31/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba2f37ee79e6338845261a3c5b1784e5d1acdff2c0785b284f1b633033d136ab", size = 279637, upload-time = "2026-08-15T08:16:27.961Z" },
+ { url = "https://files.pythonhosted.org/packages/69/2b/d8be3523ddf9f0b0f3e56d1359034aa10653a4d11564c697f802b4775766/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ce854f5f478050ade5a238731c4ca985a7d3b3cb53ff600a9b5c3b689b5f0a7a", size = 276543, upload-time = "2026-08-15T08:16:29.399Z" },
+ { url = "https://files.pythonhosted.org/packages/32/cd/4f564b8f132de25db594efc706897069f016790cea63a5669c9df2675f64/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96eefc178f8636b9c760c5829345307fd81cfae9ab1e80997dbddeb0f54ee9a3", size = 261644, upload-time = "2026-08-15T08:16:30.722Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/e3/38b975422534a608f98c360e79c2f07c763d66dd4272300d45fb1fee54b0/charset_normalizer-3.5.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:366ec70f5547c640d3ce1985722490f23faf4eb5216a7eeba78277490e78dacb", size = 259609, upload-time = "2026-08-15T08:16:32.248Z" },
+ { url = "https://files.pythonhosted.org/packages/87/bd/fbc24d825c66f1c74f6ccdea3742c3d8354a4888e86d1315a197fee69061/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:950f23cb393f85543777b0433f082cddd25b51ab398eac7971146495679efe5f", size = 252457, upload-time = "2026-08-15T08:16:33.849Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/2d/918d0e98a0e679469ed05bb2d90c2088b4d315bb612969d8499f76fb5210/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:c1dcc36dcb96abc02236e182d17e0f71430152a6c2c7447421da2d2dc144edea", size = 242240, upload-time = "2026-08-15T08:16:35.396Z" },
+ { url = "https://files.pythonhosted.org/packages/20/c8/c36f6e0b2dfec351bd38cbc05362697e58bcd073d7dbd95154290c9714ce/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:07ffd07412fc5d5e84cd8952acf9ff7e4ed7a708e69d1bada19d8ba91711353f", size = 280308, upload-time = "2026-08-15T08:16:36.825Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/7b/311b3e02e8c4092400c449c850a760d8c45d900983c83a70cc07208c551d/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f5542f9b941279d82d41eb0aa9f98eba36fe4df5c7086c651df7944935b37182", size = 258679, upload-time = "2026-08-15T08:16:38.22Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/90/082cc45599c392f28c036a497f49e0634041a785fc3849c80ccf396d096f/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a545775cfe815855ea32d7c27731d79da358ef2055b4a25830231b1622dd18aa", size = 277221, upload-time = "2026-08-15T08:16:39.62Z" },
+ { url = "https://files.pythonhosted.org/packages/58/ad/b9aecf38d805cbcf84fa94f14c5d972a16561e20296a11dc799a5dcf3763/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:494b70049a4d69aec6e8137c13af4cf8db8c9f9820a1392ac293b0dd2987a818", size = 263799, upload-time = "2026-08-15T08:16:40.885Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/23/b38a20598d5a825f85d9d7636860e56ff0db1479f86497a6e485aa9326f7/charset_normalizer-3.5.1-cp310-cp310-win32.whl", hash = "sha256:94fbf1c0c6cc0d3d5e50f9a9313a8cdca90dd696d34b381cd1704f8c9e939f20", size = 182037, upload-time = "2026-08-15T08:16:42.198Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/21/83fffb77864408b8bf0fe1ca603926401d6f8775a8e150b39aacc9958f8a/charset_normalizer-3.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:be47f99644b208bff7766314013f9acf57b056b04191d570d68ad14022cf5b1d", size = 206030, upload-time = "2026-08-15T08:16:43.787Z" },
+ { url = "https://files.pythonhosted.org/packages/86/2e/b93135b5034b1157fb29554b0d06d4844ce62282f0e0a14036f93d7ee2e7/charset_normalizer-3.5.1-cp310-cp310-win_arm64.whl", hash = "sha256:a6d095662e73e74f0a49988e0593373e243e3a52e27bfeea0a859e88acf4a0f5", size = 185092, upload-time = "2026-08-15T08:16:45.177Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/b6/034f6802e9c3f6418966cfabb7db8c9252cc2429c5098f41cc43af804149/charset_normalizer-3.5.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eda059b6bc8bc0812d626fd91a7ce01bf583df0a61296eff390fd94141a34e30", size = 363585, upload-time = "2026-08-15T08:16:46.646Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/fa/6a7e2a7c4b5451912b8c417732df79574354443592a88d616de03da66ae5/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa2bb0b37202dca27175591f761108b5d34096ade1191ffe4808bdf6b1571488", size = 251189, upload-time = "2026-08-15T08:16:48.287Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/c8/ab42b07cfd82e919f427fcfaa7c41abae8242833ad1aad66d42bae40b669/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b2b1b3fa5670c127b246df1d0c059defd41f689a868a3b9d79df9b1cac42d22", size = 239724, upload-time = "2026-08-15T08:16:49.67Z" },
+ { url = "https://files.pythonhosted.org/packages/e7/80/b9348b5d3041209f98b4cdad7655766369233f1d533f4f4f7558e9717bec/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6e5e4d73d588ca5ed09df1b7dcd1b203d1df3c542e3f50d126c947d432b10731", size = 280078, upload-time = "2026-08-15T08:16:51.228Z" },
+ { url = "https://files.pythonhosted.org/packages/82/38/083a24028304bc85bb9e376fed801178423dcbb67495f73b6ea0624e1894/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b54e7e13267d49ffbfe68e25b3cbd774dab38fa37238f71265e91b36146eb21c", size = 276650, upload-time = "2026-08-15T08:16:52.625Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/35/731ac04aa0a097fc1c97f0994c375bdb230c6c96619db794208fe664e9ce/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7b742bf31c88566b4bb6335a7f393bb322e580b6bb98df7bd0c25e6e3519ce8", size = 262325, upload-time = "2026-08-15T08:16:54.085Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/28/c2028e7021fb89c6e56868ed0e387b8e9aa811abdd2ab3208d6578d2c930/charset_normalizer-3.5.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6ba32c4d2abf1d2fe7cf27d280f4cca5664233b0f885549c7761719eb977f486", size = 261140, upload-time = "2026-08-15T08:16:55.604Z" },
+ { url = "https://files.pythonhosted.org/packages/28/f0/0c0ceec6d98b7daa62e361e418135d59685811d79ba11529aad5cdf15e84/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0722590aabf9dc6a6c0343d523c05458fa2b5047dbe6302fd526bb570600753f", size = 252791, upload-time = "2026-08-15T08:16:57.103Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/3e/48f4cd187b1c33189d86039e9cbe4f92c05454175504b44ff81806d4d1bf/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:aa1099b956fb795e686d073568f6dc002a0bb89765ea6d5b055dd7d9bf1b116c", size = 240730, upload-time = "2026-08-15T08:16:58.418Z" },
+ { url = "https://files.pythonhosted.org/packages/42/85/f9e22af69af67c54cce42be9455d9c81294f918b4ccc454db01f66efcac2/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:bd6c173f04743d483881bffa1478d5a4624475b8cd1d2194956a75548e191c18", size = 280791, upload-time = "2026-08-15T08:16:59.918Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/4c/9044135f42127630b6fa742feb51256353f6ab87a78f2fdd1de3de955a7f/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f298e218441525d3794428b4c8b8fb8662c6d3ea79925d4807ee6b9a96a3bca5", size = 259598, upload-time = "2026-08-15T08:17:01.421Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/ed/1dd7cfebb4e75812934c49ca3b79757d11948053f7937ab7070c151f3c55/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:6e2912d4babbc65196ac13c2f53468dc57fb8b9c25ef913e8c59ddf7c6dc0e1b", size = 278217, upload-time = "2026-08-15T08:17:02.782Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/eb/239c84503cc9e3ba6eb34686a24bc66e84f3924efdd7e38e751a19f6bc10/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3d27167433c0d5f18dc850f07d0b3816221984fecdc405d6c157a6f0b8f8e9e6", size = 263417, upload-time = "2026-08-15T08:17:04.216Z" },
+ { url = "https://files.pythonhosted.org/packages/37/ab/4e4510e1e288478e2c8333131d1c1382382ba8cd2165053c79e39d1da961/charset_normalizer-3.5.1-cp311-cp311-win32.whl", hash = "sha256:ac00177c4831ffa650f8609e4bdddd5fe09c03b1c0c47acece7e6ea20421598b", size = 181774, upload-time = "2026-08-15T08:17:05.58Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/57/32f0ccea59e8612057c61d6fd22ef2cb63cca93c9fe594094919696ac170/charset_normalizer-3.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:f9b1e28d0e8dbfa858abdba91d6b547beaf2df1a59bec6da6faae7b96a4991a9", size = 206653, upload-time = "2026-08-15T08:17:07.075Z" },
+ { url = "https://files.pythonhosted.org/packages/17/d4/b65c433fc521e58b5f54293982a5e51c05cb5f2dd3f1c7a6acb65b75324e/charset_normalizer-3.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:ae31a1a1db2ee6cc2942fccaf695c934bc7f3db9f2133a3fef1f367cf1a4ab10", size = 185630, upload-time = "2026-08-15T08:17:08.502Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/97/fb4e82231aba271ffd775a1b4993b0defc4e3059f286ae41d9433409fe85/charset_normalizer-3.5.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2", size = 331467, upload-time = "2026-08-15T08:19:50.959Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/2f/fe3f187327aac18e2d54e9d2b08e15d27bf9b642d9e51c219f130fc34d1a/charset_normalizer-3.5.1-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99", size = 253057, upload-time = "2026-08-15T08:19:52.654Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/c7/9e48cee5c161fe24da823b61bf381921d77cb994a0a4de148e95018c1984/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2", size = 240930, upload-time = "2026-08-15T08:19:54.163Z" },
+ { url = "https://files.pythonhosted.org/packages/49/e0/716601f3cc69be7b198951150c75ead1ece33c3c8036ff6ffa46029659a0/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235", size = 230822, upload-time = "2026-08-15T08:19:55.807Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/05/71bfc5caa0abcc45aea1f6a4d50ac68e59605ddc7666fe8494f4cd229665/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598", size = 260037, upload-time = "2026-08-15T08:19:57.312Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/92/de7e32ed05341e7a9c4c877c318418197b7f2d66a3b68d561bf2ac57ca3e/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96", size = 255097, upload-time = "2026-08-15T08:19:59.056Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/7b/ade0a122600319dfa0b1000ab0f9731c94a817904cf3c5de408c73a4ede7/charset_normalizer-3.5.1-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962", size = 250166, upload-time = "2026-08-15T08:20:00.612Z" },
+ { url = "https://files.pythonhosted.org/packages/75/9c/019fbb9f4834491a160951349b1a3714439376f66e5f7cf18b4f18f0c7aa/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3", size = 241821, upload-time = "2026-08-15T08:20:02.321Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/b8/11d4840bfc99330cc7fbcc2681ee5a044553a6e77655508d8f9b2bff7b34/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950", size = 232529, upload-time = "2026-08-15T08:20:04.008Z" },
+ { url = "https://files.pythonhosted.org/packages/18/96/2b3a21492d9f65171ac75d872f5018260013d00bfa0ff70ec9f179148cbd/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8", size = 260348, upload-time = "2026-08-15T08:20:05.877Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/aa/a69a2028e8bd052476c245460ab19d7de595de084dd968f2d75cd50c3e25/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031", size = 247234, upload-time = "2026-08-15T08:20:07.487Z" },
+ { url = "https://files.pythonhosted.org/packages/35/8a/3d130aeabcaf3d2466af76b7b141c08d9e89c9016ab4b7cdd0f7dc2d1c62/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072", size = 256917, upload-time = "2026-08-15T08:20:09.142Z" },
+ { url = "https://files.pythonhosted.org/packages/80/c2/a7379b840292d0c1ab9fbd17d1f3967aa81794dc95bc74be8999d7fedcf7/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d", size = 254846, upload-time = "2026-08-15T08:20:10.727Z" },
+ { url = "https://files.pythonhosted.org/packages/01/65/d43b714731bb2f40d4053dfa00ecfc1c5a301f8e3316c5db3a09af59fe94/charset_normalizer-3.5.1-cp37-abi3-win32.whl", hash = "sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc", size = 174216, upload-time = "2026-08-15T08:20:12.334Z" },
+ { url = "https://files.pythonhosted.org/packages/35/4f/b911ed898b26a09789eba9c9200c999aff6c61b4bafaf4838e56d1a1e1a3/charset_normalizer-3.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959", size = 199764, upload-time = "2026-08-15T08:20:13.908Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/a7/920baf467bfd9bf689f3b318340f37aee4572a71f162bd8db51da55ba4fa/charset_normalizer-3.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e", size = 287318, upload-time = "2026-08-15T08:20:15.551Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" },
+]
+
+[[package]]
+name = "cloudpickle"
+version = "3.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.3.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version < '3.11' and sys_platform == 'win32'",
+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version < '3.11' and sys_platform == 'darwin'",
+]
+dependencies = [
+ { name = "numpy", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/12/a3/da4153ec8fe25d263aa48c1a4cbde7f49b59af86f0b6f7862788c60da737/contourpy-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba38e3f9f330af820c4b27ceb4b9c7feee5fe0493ea53a8720f4792667465934", size = 268551, upload-time = "2025-04-15T17:34:46.581Z" },
+ { url = "https://files.pythonhosted.org/packages/2f/6c/330de89ae1087eb622bfca0177d32a7ece50c3ef07b28002de4757d9d875/contourpy-1.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dc41ba0714aa2968d1f8674ec97504a8f7e334f48eeacebcaa6256213acb0989", size = 253399, upload-time = "2025-04-15T17:34:51.427Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/bd/20c6726b1b7f81a8bee5271bed5c165f0a8e1f572578a9d27e2ccb763cb2/contourpy-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9be002b31c558d1ddf1b9b415b162c603405414bacd6932d031c5b5a8b757f0d", size = 312061, upload-time = "2025-04-15T17:34:55.961Z" },
+ { url = "https://files.pythonhosted.org/packages/22/fc/a9665c88f8a2473f823cf1ec601de9e5375050f1958cbb356cdf06ef1ab6/contourpy-1.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2e74acbcba3bfdb6d9d8384cdc4f9260cae86ed9beee8bd5f54fee49a430b9", size = 351956, upload-time = "2025-04-15T17:35:00.992Z" },
+ { url = "https://files.pythonhosted.org/packages/25/eb/9f0a0238f305ad8fb7ef42481020d6e20cf15e46be99a1fcf939546a177e/contourpy-1.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e259bced5549ac64410162adc973c5e2fb77f04df4a439d00b478e57a0e65512", size = 320872, upload-time = "2025-04-15T17:35:06.177Z" },
+ { url = "https://files.pythonhosted.org/packages/32/5c/1ee32d1c7956923202f00cf8d2a14a62ed7517bdc0ee1e55301227fc273c/contourpy-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad687a04bc802cbe8b9c399c07162a3c35e227e2daccf1668eb1f278cb698631", size = 325027, upload-time = "2025-04-15T17:35:11.244Z" },
+ { url = "https://files.pythonhosted.org/packages/83/bf/9baed89785ba743ef329c2b07fd0611d12bfecbedbdd3eeecf929d8d3b52/contourpy-1.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cdd22595308f53ef2f891040ab2b93d79192513ffccbd7fe19be7aa773a5e09f", size = 1306641, upload-time = "2025-04-15T17:35:26.701Z" },
+ { url = "https://files.pythonhosted.org/packages/d4/cc/74e5e83d1e35de2d28bd97033426b450bc4fd96e092a1f7a63dc7369b55d/contourpy-1.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4f54d6a2defe9f257327b0f243612dd051cc43825587520b1bf74a31e2f6ef2", size = 1374075, upload-time = "2025-04-15T17:35:43.204Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/42/17f3b798fd5e033b46a16f8d9fcb39f1aba051307f5ebf441bad1ecf78f8/contourpy-1.3.2-cp310-cp310-win32.whl", hash = "sha256:f939a054192ddc596e031e50bb13b657ce318cf13d264f095ce9db7dc6ae81c0", size = 177534, upload-time = "2025-04-15T17:35:46.554Z" },
+ { url = "https://files.pythonhosted.org/packages/54/ec/5162b8582f2c994721018d0c9ece9dc6ff769d298a8ac6b6a652c307e7df/contourpy-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c440093bbc8fc21c637c03bafcbef95ccd963bc6e0514ad887932c18ca2a759a", size = 221188, upload-time = "2025-04-15T17:35:50.064Z" },
+ { url = "https://files.pythonhosted.org/packages/b3/b9/ede788a0b56fc5b071639d06c33cb893f68b1178938f3425debebe2dab78/contourpy-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a37a2fb93d4df3fc4c0e363ea4d16f83195fc09c891bc8ce072b9d084853445", size = 269636, upload-time = "2025-04-15T17:35:54.473Z" },
+ { url = "https://files.pythonhosted.org/packages/e6/75/3469f011d64b8bbfa04f709bfc23e1dd71be54d05b1b083be9f5b22750d1/contourpy-1.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b7cd50c38f500bbcc9b6a46643a40e0913673f869315d8e70de0438817cb7773", size = 254636, upload-time = "2025-04-15T17:35:58.283Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/2f/95adb8dae08ce0ebca4fd8e7ad653159565d9739128b2d5977806656fcd2/contourpy-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6658ccc7251a4433eebd89ed2672c2ed96fba367fd25ca9512aa92a4b46c4f1", size = 313053, upload-time = "2025-04-15T17:36:03.235Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/a6/8ccf97a50f31adfa36917707fe39c9a0cbc24b3bbb58185577f119736cc9/contourpy-1.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:70771a461aaeb335df14deb6c97439973d253ae70660ca085eec25241137ef43", size = 352985, upload-time = "2025-04-15T17:36:08.275Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/b6/7925ab9b77386143f39d9c3243fdd101621b4532eb126743201160ffa7e6/contourpy-1.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65a887a6e8c4cd0897507d814b14c54a8c2e2aa4ac9f7686292f9769fcf9a6ab", size = 323750, upload-time = "2025-04-15T17:36:13.29Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/f3/20c5d1ef4f4748e52d60771b8560cf00b69d5c6368b5c2e9311bcfa2a08b/contourpy-1.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3859783aefa2b8355697f16642695a5b9792e7a46ab86da1118a4a23a51a33d7", size = 326246, upload-time = "2025-04-15T17:36:18.329Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/e5/9dae809e7e0b2d9d70c52b3d24cba134dd3dad979eb3e5e71f5df22ed1f5/contourpy-1.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eab0f6db315fa4d70f1d8ab514e527f0366ec021ff853d7ed6a2d33605cf4b83", size = 1308728, upload-time = "2025-04-15T17:36:33.878Z" },
+ { url = "https://files.pythonhosted.org/packages/e2/4a/0058ba34aeea35c0b442ae61a4f4d4ca84d6df8f91309bc2d43bb8dd248f/contourpy-1.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d91a3ccc7fea94ca0acab82ceb77f396d50a1f67412efe4c526f5d20264e6ecd", size = 1375762, upload-time = "2025-04-15T17:36:51.295Z" },
+ { url = "https://files.pythonhosted.org/packages/09/33/7174bdfc8b7767ef2c08ed81244762d93d5c579336fc0b51ca57b33d1b80/contourpy-1.3.2-cp311-cp311-win32.whl", hash = "sha256:1c48188778d4d2f3d48e4643fb15d8608b1d01e4b4d6b0548d9b336c28fc9b6f", size = 178196, upload-time = "2025-04-15T17:36:55.002Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/fe/4029038b4e1c4485cef18e480b0e2cd2d755448bb071eb9977caac80b77b/contourpy-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:5ebac872ba09cb8f2131c46b8739a7ff71de28a24c869bcad554477eb089a878", size = 222017, upload-time = "2025-04-15T17:36:58.576Z" },
+ { url = "https://files.pythonhosted.org/packages/33/05/b26e3c6ecc05f349ee0013f0bb850a761016d89cec528a98193a48c34033/contourpy-1.3.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fd93cc7f3139b6dd7aab2f26a90dde0aa9fc264dbf70f6740d498a70b860b82c", size = 265681, upload-time = "2025-04-15T17:44:59.314Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/25/ac07d6ad12affa7d1ffed11b77417d0a6308170f44ff20fa1d5aa6333f03/contourpy-1.3.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:107ba8a6a7eec58bb475329e6d3b95deba9440667c4d62b9b6063942b61d7f16", size = 315101, upload-time = "2025-04-15T17:45:04.165Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/4d/5bb3192bbe9d3f27e3061a6a8e7733c9120e203cb8515767d30973f71030/contourpy-1.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ded1706ed0c1049224531b81128efbd5084598f18d8a2d9efae833edbd2b40ad", size = 220599, upload-time = "2025-04-15T17:45:08.456Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/c0/91f1215d0d9f9f343e4773ba6c9b89e8c0cc7a64a6263f21139da639d848/contourpy-1.3.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5f5964cdad279256c084b69c3f412b7801e15356b16efa9d78aa974041903da0", size = 266807, upload-time = "2025-04-15T17:45:15.535Z" },
+ { url = "https://files.pythonhosted.org/packages/d4/79/6be7e90c955c0487e7712660d6cead01fa17bff98e0ea275737cc2bc8e71/contourpy-1.3.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49b65a95d642d4efa8f64ba12558fcb83407e58a2dfba9d796d77b63ccfcaff5", size = 318729, upload-time = "2025-04-15T17:45:20.166Z" },
+ { url = "https://files.pythonhosted.org/packages/87/68/7f46fb537958e87427d98a4074bcde4b67a70b04900cfc5ce29bc2f556c1/contourpy-1.3.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8c5acb8dddb0752bf252e01a3035b21443158910ac16a3b0d20e7fed7d534ce5", size = 221791, upload-time = "2025-04-15T17:45:24.794Z" },
+]
+
+[[package]]
+name = "contourpy"
+version = "1.3.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version >= '3.11' and sys_platform == 'win32'",
+ "python_full_version >= '3.11' and sys_platform == 'emscripten'",
+ "python_full_version >= '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version >= '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version >= '3.11' and sys_platform == 'darwin'",
+]
+dependencies = [
+ { name = "numpy", marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" },
+ { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" },
+ { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" },
+ { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" },
+ { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" },
+ { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" },
+ { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" },
+ { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" },
+]
+
+[[package]]
+name = "cryptography"
+version = "50.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "cffi", marker = "(python_full_version < '3.11' and platform_python_implementation != 'PyPy' and sys_platform == 'emscripten') or (platform_python_implementation != 'PyPy' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+ { name = "typing-extensions", marker = "python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/ad/5d6702db60b1e40b41ef513b6967ff5848f307d50f8449baf1634f5908f1/cryptography-50.0.1.tar.gz", hash = "sha256:5dd9bda1c12b4162f6ff568eeb5e0ff956c28d14406e875cfe8a63a2d414ff20", size = 880381, upload-time = "2026-08-25T19:45:45.499Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/90/34/9ce9a62ed9dc82ca9fd6a34445b6904af56e5f38b3eae2ed32e49c36053d/cryptography-50.0.1-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:53e279950892dc102c6b4e52af03ae5ea92fac572a1ddab78ca73a997f62b69f", size = 4723133, upload-time = "2026-08-25T19:44:05.461Z" },
+ { url = "https://files.pythonhosted.org/packages/57/26/e6d4fc8512a51a5f9ee7bfdbfb853bce1197087df40c9ad993ad370b846f/cryptography-50.0.1-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ff838d62ec1bfce4f9ba7fa16f4a7b554cd8d0c299e6be37502161a660c84eef", size = 4712478, upload-time = "2026-08-25T19:44:07.375Z" },
+ { url = "https://files.pythonhosted.org/packages/e6/de/d3cdc2815697aae84126cbd6a030ca7b6b452e28a88b501b836bd3aa7a86/cryptography-50.0.1-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e74591e283fe6eb956416c929eb58262a719fe0311fd9054c62c3350ed8760d8", size = 4730726, upload-time = "2026-08-25T19:44:09.294Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/1b/82f0f0d8858d4432be1af790477edf62aef90324041aa07c57e57bef1af7/cryptography-50.0.1-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:51593d180cf6d179bde5c5d065bed81386b1f381656ae7d042b7ffc87a9895ad", size = 4746720, upload-time = "2026-08-25T19:44:14.051Z" },
+ { url = "https://files.pythonhosted.org/packages/29/ba/042ca458b8c64348c768284b5d23e69b92ed53d057ab779fee628564676d/cryptography-50.0.1-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:359e62deae718bce96170e223fdcb6357e4fbd3bb7a3a75f4430763532560e49", size = 4361866, upload-time = "2026-08-25T19:44:16.167Z" },
+ { url = "https://files.pythonhosted.org/packages/39/3b/e96c1ef71edef71057c7e3c3d982ce8fda554e0c52d0cc19c18845cde3eb/cryptography-50.0.1-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e2ca8fd1b6b4b82a1c4cb02841d0837e3c12336c2e24b520ab8ab3b969733d8f", size = 4730028, upload-time = "2026-08-25T19:44:18.085Z" },
+ { url = "https://files.pythonhosted.org/packages/85/66/6ccca4722987ddedaa7fc9c3f4708af7431f5535666c174350830888c6b7/cryptography-50.0.1-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:51afcfceb15597cf2635068e4ac9a56b2abde622edde17f37d85fd7b5306497a", size = 4746230, upload-time = "2026-08-25T19:44:22.376Z" },
+ { url = "https://files.pythonhosted.org/packages/13/0e/b1f92e013228111413f2e6743948b80bc24dfd3c1b87ba98ceea16f5df89/cryptography-50.0.1-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:be224a65493ec5b74a158ff22a5522ce4a5ca1e543c647a3a4730d4a09e5f959", size = 4862596, upload-time = "2026-08-25T19:44:24.472Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/22/c3654cccc856e9d682817b04ac3ee79731cb09ca6f95996a95c904de2883/cryptography-50.0.1-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9ebcdd5519be9b652a46f507817a74591774fc3d6923ac364e4dfa64e36b291b", size = 5014082, upload-time = "2026-08-25T19:44:26.709Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/a5/9ec7e81e8526c0d7a387d73386b2daed3f39e10d81a85930bd1b6bfba65c/cryptography-50.0.1-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:05ba322c4da95b262a212c345af888ef2c37c88c0509756ea00a0e6d68850f23", size = 4751900, upload-time = "2026-08-25T19:45:00.401Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/3c/0e77bd5ffcf078e9dd27d3074aad6c030d9b10d0bf69329d573c927a188c/cryptography-50.0.1-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e22dfed744bd4002e909464cb23d2f0b05c6f3113a79ef2e9864a53db737c733", size = 4738357, upload-time = "2026-08-25T19:45:02.786Z" },
+ { url = "https://files.pythonhosted.org/packages/27/3a/3c5f80daa4dcd47323c7af8a2fcb90de27a33564d4fcac69846c0972691a/cryptography-50.0.1-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:4c4188f7c0cf655be5c06342b817ed0f9595b69ffa2b12026e5353eed29dea88", size = 4758474, upload-time = "2026-08-25T19:45:04.889Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/51/3f9701867a46b6c1740c9b52fc4d3bed6cbdcfedcc9b6e64305c07f39cff/cryptography-50.0.1-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:407fe2b6db00939c05c0e945e9914238f2f0a430974839429dafc82b1ee6bee5", size = 4772942, upload-time = "2026-08-25T19:45:09.396Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/5c/13ea642e08e2544d0f5396122055f4820cfacb3203562197b5967125ea97/cryptography-50.0.1-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:2b34d76a652ea2b6faf777c35df230c5637842cd904e04f16230c3f9f03e4361", size = 4383347, upload-time = "2026-08-25T19:45:11.659Z" },
+ { url = "https://files.pythonhosted.org/packages/84/d5/7d1fe1cb93f91c428093ff234e128c89ba8ea61a6f26aab406081f9b996e/cryptography-50.0.1-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:01f41478cf33fc605a6a089cd56d28b45c6c0b45a1928b61797f2621a04bac71", size = 4758050, upload-time = "2026-08-25T19:45:13.745Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/eb/5d7124083e8d8cda8f5b348f544b71ad6f707ad63193758ef4d8e569da02/cryptography-50.0.1-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9dde0a357190eb3b1da1bb9ab750e9c85cba82ca5977aa0836cbb94e92611239", size = 4772694, upload-time = "2026-08-25T19:45:18.315Z" },
+ { url = "https://files.pythonhosted.org/packages/63/8e/f1f955e0921dd2b6d22eae7e8d24a4c4b638d10735ffbf6a71f99eb0fcb8/cryptography-50.0.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd3718b960d0b5dd213cdf03f3bcb7000e69dda0de8b956061947ff6bcff5558", size = 4888413, upload-time = "2026-08-25T19:45:20.4Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/ab/89e2b798d2c3925f82e2bb72d5979f3d2f6da2dd22ef4a8cd8b70d920039/cryptography-50.0.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2a93d05e34d5f67fba6f891fe85d929999baa7195e853923ea6d7576c9e68c5e", size = 5044355, upload-time = "2026-08-25T19:45:22.353Z" },
+ { url = "https://files.pythonhosted.org/packages/14/9a/6d3a4d7852e22d657438b7bf51f66102c7d71c0e1fafeec652281d0403e5/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:5fe939deeb161024a6be98229c953b6591fef1f41214497a78fe793a244c017f", size = 4698675, upload-time = "2026-08-25T19:45:28.658Z" },
+ { url = "https://files.pythonhosted.org/packages/73/35/5c3717edf9e68a0550ce04e28eab493fe545eccd81742af03f6a75fe260b/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:fb4b9672d389c738b175c4166e78310f8a70358886aacd9173ee03a85ffdc671", size = 4707410, upload-time = "2026-08-25T19:45:30.816Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/e0/e786934472e3ac4ecdecc7b129a0ca1a2a40dffdafcf2c3ea9d4397f8def/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:d63ae8f6481fec907ac0f588eee8a90aefde112c633131fe540e5711ddbb5a4e", size = 4698378, upload-time = "2026-08-25T19:45:33.043Z" },
+ { url = "https://files.pythonhosted.org/packages/51/cf/5b3f53a0b74d122f023476ede40ba5d3e70d5cf475f73b899740d26a4fb2/cryptography-50.0.1-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:804728ce710890870f3aaa344b2e161172d258d768ac139d02cfd9092d0d94e6", size = 4706889, upload-time = "2026-08-25T19:45:35.086Z" },
+]
+
+[[package]]
+name = "cuda-bindings"
+version = "13.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "cuda-pathfinder", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a9/21/8464d133752951c154feafb3b65c297e7d80f301183d220bec4c830f1441/cuda_bindings-13.3.1-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:120fcc53d57903df529c3486962c56528cba5b7d6c57c99537320ed9922c8b86", size = 6073403, upload-time = "2026-05-29T23:11:36.22Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/1f/5ef51f5fbaa5d4d3201bb3d7555af028ec1aa4416275ccbf73c9e34e3d2d/cuda_bindings-13.3.1-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9851b0caa8bfd3bc6fa054eaf57bea7c8e9c3a62db2d2621224677f49f3c53d0", size = 6675244, upload-time = "2026-05-29T23:11:38.664Z" },
+ { url = "https://files.pythonhosted.org/packages/51/6b/457ca12dad3ee9bfcc9a545cfd6b64b359ba49de40f776f6e028e678f262/cuda_bindings-13.3.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c5879712accf6e14bb01aa5e67440eb84998b8d104b509cc7a6dc0b8f656a474", size = 6053539, upload-time = "2026-05-29T23:11:43.19Z" },
+ { url = "https://files.pythonhosted.org/packages/95/7a/c5e3c34a409b148f5c0f5a4ea374158f95d488862c1dffedf9aa5c639df9/cuda_bindings-13.3.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:04436a9364059c84b8f9636f359eccda1cf814341f5b670c71d80d2f79dbc708", size = 6674166, upload-time = "2026-05-29T23:11:45.478Z" },
+]
+
+[[package]]
+name = "cuda-pathfinder"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a1/b1/ef21259ec74fe0b265ed201379de1d0ef7c14178313ee03705952f1b7093/cuda_pathfinder-1.8.0-py3-none-any.whl", hash = "sha256:c44e574dc997fae2814721d1ae97d0fd6db76db82decbe9b753bf75de53f515e", size = 62539, upload-time = "2026-08-27T21:33:03.229Z" },
+]
+
+[[package]]
+name = "cuda-toolkit"
+version = "13.0.3.0"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d1/c7/a79086a62c98befcdb8349656c6f114e2db3b8b2422f6e25c97a7f2a9a3c/cuda_toolkit-13.0.3.0-py2.py3-none-any.whl", hash = "sha256:d693caaa261214ddd7dbb60d68e71cbed884e68c2be7509778f3051da0b91c3f", size = 2512, upload-time = "2026-04-14T00:50:08.173Z" },
+]
+
+[package.optional-dependencies]
+cublas = [
+ { name = "nvidia-cublas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+ { name = "nvidia-cuda-nvrtc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+cudart = [
+ { name = "nvidia-cuda-runtime", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+cufft = [
+ { name = "nvidia-cufft", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+ { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+cufile = [
+ { name = "nvidia-cufile", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+cupti = [
+ { name = "nvidia-cuda-cupti", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+curand = [
+ { name = "nvidia-curand", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+cusolver = [
+ { name = "nvidia-cublas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+ { name = "nvidia-cusolver", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+ { name = "nvidia-cusparse", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+ { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+cusparse = [
+ { name = "nvidia-cusparse", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+ { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+nvjitlink = [
+ { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+nvrtc = [
+ { name = "nvidia-cuda-nvrtc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+nvtx = [
+ { name = "nvidia-nvtx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" },
+]
+
+[[package]]
+name = "docutils"
+version = "0.23"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/39/a4/5180d9afc57e8fca05601dd652bdff19604c218814037fe90ffc7625a50a/docutils-0.23.tar.gz", hash = "sha256:746f5060322511280a1e50eb76846ed6bf2342984b2ac04dc42caa1a8d78799e", size = 2303823, upload-time = "2026-05-27T17:41:06.934Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/32/91/30151a39f7570f448ed84529390628a651d7f27c87d73c9b887f8189695e/docutils-0.23-py3-none-any.whl", hash = "sha256:25d013af9bf23bc1c7b2b093dff4208166c53a94786c9e447808335ef1185fea", size = 634701, upload-time = "2026-05-27T17:40:58.442Z" },
+]
+
+[[package]]
+name = "ensemble-boxes"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "numba" },
+ { name = "numpy" },
+ { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+ { name = "pandas", version = "3.0.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4e/d4/d313c9de69f1d628fe66e73b44c876ce5db250c7ac41fb7c1ed14644198a/ensemble_boxes-1.0.9.tar.gz", hash = "sha256:16a68101cb11606daac861e0e30f27e9748487e8166053dbf0a214db497ed4ae", size = 9942, upload-time = "2022-04-20T21:10:53.48Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0e/5b/58e47cd45fc18da37205a80689606e0e203810f1beadbdaae620f491892b/ensemble_boxes-1.0.9-py3-none-any.whl", hash = "sha256:f095f34d28034213791b8793b9de4d8ba6e40e6a2a6af02336b84c485d853d6a", size = 23897, upload-time = "2022-04-20T21:10:51.368Z" },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.32.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/30/03b03951873a1a0ffc7e8ca0e10c15597b59e8d0e39260704cd2ea087bc4/filelock-3.32.4.tar.gz", hash = "sha256:2bde2e4cf732e0153406d8a7bc80620ecf5e621fe0d25e41143c4e3b4733ff30", size = 222126, upload-time = "2026-08-23T17:37:55.363Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/01/a4/9b63d595d748e3aff8812b65eacc1a2c4bd90b7c2012e08e72373b4835eb/filelock-3.32.4-py3-none-any.whl", hash = "sha256:22e58ca3b1ae3b98993b762d7338367ae64fe50252bf78d59da3bfebcdf1cedd", size = 99864, upload-time = "2026-08-23T17:37:53.913Z" },
+]
+
+[[package]]
+name = "fonttools"
+version = "4.63.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/84/69/c97f2c18e0db87d2c7b15da1974dace76ae938f1cfa22e2727a648b7ed43/fonttools-4.63.0.tar.gz", hash = "sha256:caeb583deeb5168e694b65cda8b4ee62abedfa66cf88488734466f2366b9c4e0", size = 3597189, upload-time = "2026-05-14T12:04:30.958Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f2/c9/4141c90a90db20f807c7e10bfd689fe53eb8f7f4caff58ee4d4dfe46919f/fonttools-4.63.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e3297a6a4059b4acc3a1e9a8b04741f240a80044eef08ebd32e8b5bcdddce75b", size = 2884632, upload-time = "2026-05-14T12:02:38.56Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/46/ad12b5c10eae602d7ef814b02afa08aacbf89da917fed5b071282b7eadc2/fonttools-4.63.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b1cd75a03ad8cb5bc40c90bfde68c0c47de423aa19e5c0f362b43520645eea94", size = 2429441, upload-time = "2026-05-14T12:02:41.162Z" },
+ { url = "https://files.pythonhosted.org/packages/90/8f/bdca24a84c81d56fffed052229cdcff368f6e05882e526f4558891481f65/fonttools-4.63.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0425b277a59cff3d80ca42162a8de360f318438a2ac83570842a678d826d579", size = 4946346, upload-time = "2026-05-14T12:02:43.41Z" },
+ { url = "https://files.pythonhosted.org/packages/04/59/a639c0e136441ee91a65b56fdf89e5d075927e7a09c559d1b0f5276577db/fonttools-4.63.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d7e5c9973aa04c95650c96e5f5ad865fbf42d62079163ecfab1e01cbc2504c22", size = 4903184, upload-time = "2026-05-14T12:02:45.742Z" },
+ { url = "https://files.pythonhosted.org/packages/e6/53/91b7e0cb45b536f3da1b29ba8cbab89f27e8b986809e0b1982303a3f4eca/fonttools-4.63.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cb014d58140a38135f16064c74c652ed57aa0b75cbf8bb59cac821f7edb5334e", size = 4922967, upload-time = "2026-05-14T12:02:48.386Z" },
+ { url = "https://files.pythonhosted.org/packages/c7/b7/87439bf44e6b97c5538cd29d0b7e366a5b8ce2cc132a4134fb67fa3f2fa2/fonttools-4.63.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:032038247a96c1690f9f31e377c389383c902531b085aa4e4dabd6f57f870e69", size = 5042799, upload-time = "2026-05-14T12:02:50.424Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/7c/8b96c3263b89ef99cded544c0f0636686f85dbd3c211c4dceef0231fca23/fonttools-4.63.0-cp310-cp310-win32.whl", hash = "sha256:a8b33a82979e0a6a34ff435cc81317be1f95ec1ebb7a3a2d1c8a6a54f02ae44e", size = 1519704, upload-time = "2026-05-14T12:02:52.523Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/4d/2c2f0069970b6907de8fb5b05c5c0193cc22f717df151d1c7aef1c738f58/fonttools-4.63.0-cp310-cp310-win_amd64.whl", hash = "sha256:0c18358a155d75034911c5ee397a5b44cd19dd325dbb8b35fb60bf421d6a72ac", size = 1568666, upload-time = "2026-05-14T12:02:54.917Z" },
+ { url = "https://files.pythonhosted.org/packages/75/2b/a7f1545bdf5da69c4bda0cea2a5781f0ad2a6623e0277267672db43c5fe6/fonttools-4.63.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2b8ae05d9eacf6081414d759c0a352769ac28ce31280d6bb8e77b03f9e3c449f", size = 2881793, upload-time = "2026-05-14T12:02:56.645Z" },
+ { url = "https://files.pythonhosted.org/packages/49/50/965308c703f085f225db2886813b27e015b8b3438c350b22dd65b52c2a2c/fonttools-4.63.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:79cdc9f567aec74a72918fd060283911406750cbc9fd28c1316023deb6ce31a9", size = 2428130, upload-time = "2026-05-14T12:02:58.891Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/38/6937fbd7f2dc3a6b48725851bc2c15ec949b9af14d9bbcb5fe83cdf9bdf9/fonttools-4.63.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c14b4fd138c4bafcca294765c547914e1aa431ae1ca94ab99d8db08c958bd3b", size = 5111952, upload-time = "2026-05-14T12:03:01.263Z" },
+ { url = "https://files.pythonhosted.org/packages/0b/43/a81f20050a3115b57d62c8e781446949512eac36690dc384ccea65ff4cc1/fonttools-4.63.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d76ac49f929aecaf82d83250b8347e099d7aecba0f4726c1d9b6df3b8bb5fe18", size = 5082308, upload-time = "2026-05-14T12:03:03.211Z" },
+ { url = "https://files.pythonhosted.org/packages/67/00/cdd9d4944ca6ae280d01e69cc37bde3bf663630b837a6fc6d2cd65d80e0e/fonttools-4.63.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dcf076a4474fe0d7367e5bbf5b052c7284fa1feca729c04176ce513521afd8a0", size = 5087932, upload-time = "2026-05-14T12:03:05.147Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/f1/0aa0dbea778c75adbef223c42019fd47d22262b905974d62d829545d485f/fonttools-4.63.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7dd683fef0663e9f0f45cf541d788d24caa3ec9db50796b588e1757d8b3bc007", size = 5213271, upload-time = "2026-05-14T12:03:07.238Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/99/253e4056e1f0e67b9390125a154b73b5eb73ad521bece95c004858fdeec2/fonttools-4.63.0-cp311-cp311-win32.whl", hash = "sha256:afefc1ed0a59785a7fb06ea7e1678e849c193e1e387db783579bc7b3056fcfcb", size = 2304473, upload-time = "2026-05-14T12:03:09.271Z" },
+ { url = "https://files.pythonhosted.org/packages/08/60/defa5e69641db890a63be281f41345f4c33b157824eaf0b9fad3e08b0dcb/fonttools-4.63.0-cp311-cp311-win_amd64.whl", hash = "sha256:063e08bd17bd5a90127a14123de0d6a952dbc847695fd98b63c043d58057f90c", size = 2356389, upload-time = "2026-05-14T12:03:11.53Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/47/c99d5268f354002ce80f8d029cd9d7d872969da1de8b93d32de4dc56d6f4/fonttools-4.63.0-py3-none-any.whl", hash = "sha256:445af2eab030a16b9171ea8bdda7ebf7d96bda2df88ee182a464252f6e05e20d", size = 1164562, upload-time = "2026-05-14T12:04:29.092Z" },
+]
+
+[[package]]
+name = "fsspec"
+version = "2026.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/00/78/f34251dadb8f3921264a1d9b8946f5e542014ee2614b285261b4e40e6775/fsspec-2026.7.0.tar.gz", hash = "sha256:c803c40f4cf860b49dea58ee3e1c33cb9c790520e233537e1340049f89b82a88", size = 317040, upload-time = "2026-07-28T16:34:51.052Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/fd/3c/6a2bf344106328fd04963664a60b9bb6496fc25df8e962fcdc1367285fb9/fsspec-2026.7.0-py3-none-any.whl", hash = "sha256:b57ddbafedfaef7018c1ecab32aa200a9d7ca26b77965f64e48b70061249d279", size = 206583, upload-time = "2026-07-28T16:34:49.538Z" },
+]
+
+[[package]]
+name = "grpcio"
+version = "1.83.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0c/98/304898ac4e04e2d5e4e4c2eadc178b1f2a16d5f4bc2f91306c87d64680b9/grpcio-1.83.0.tar.gz", hash = "sha256:7674587248fbbb2ac6e4eecf83a8a0f3d91a928f941de571acfd3a2f007fbc24", size = 13428824, upload-time = "2026-07-23T15:20:37.759Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/6b/fd/655c8a773d728bc3c93fb4713ae4bf79ffc75996f86fb78b2974c8e1dfbd/grpcio-1.83.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:fba099b716e73512d61b97f71ea3c31a72abb36904036e316bf4dd148ca8dcc8", size = 6334247, upload-time = "2026-07-23T15:18:53.099Z" },
+ { url = "https://files.pythonhosted.org/packages/d4/9a/1ce5760d35a04a992006dd2f79afff2db548f93ee7426fa95c9f1fc90c61/grpcio-1.83.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:6755ed67cc3e454d51ae9f6e1915b80d3942fa4de956ef48dacd45ab7f40b727", size = 12168650, upload-time = "2026-07-23T15:18:56.348Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/ab/bbcb5be0a1a6cb21f036e2afdd4f7a70147cfb7a7b42648a310d7c43acfc/grpcio-1.83.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5882c1a721b50ce0123ee5e839e1ab059ad72a7ade76cdf2d5bd833b56791acf", size = 6916899, upload-time = "2026-07-23T15:18:58.339Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/d2/4c27977ecb3b3f9f363b93f570e001cb24ef264a9a907d7fd0f949ed59f0/grpcio-1.83.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4e3eedfc92b6b9f2960115e7e620cf0cbf80bb7849a51ce3820dc54dfd88b6b9", size = 7648761, upload-time = "2026-07-23T15:19:00.071Z" },
+ { url = "https://files.pythonhosted.org/packages/23/49/0c823a7627ff2e69a61e4a53c4edf215272892fc2c47c6431f033d46f4cc/grpcio-1.83.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4fcaa7c45c45b4a89e2867d1f1785d9481a788399d915e341ed2eb49aeef9dd4", size = 7074920, upload-time = "2026-07-23T15:19:02.293Z" },
+ { url = "https://files.pythonhosted.org/packages/3b/ce/963f01ff7c789a76909c9691b704112e02ca1e11c10405cd99c2bd7c40f1/grpcio-1.83.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:6b6c666a1d5613ff360c9e90f44665e3a88b25a815209ddbc0917eec281931cb", size = 7598046, upload-time = "2026-07-23T15:19:03.921Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/de/1ce6bdefc847a7973040d10cebc8996c653a2a687c0a4da8d05dcab4e397/grpcio-1.83.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:6be5c807b717be3dd649446f021301fd7907e376318675d2147823071034112a", size = 8634792, upload-time = "2026-07-23T15:19:05.633Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/8b/7fe6a73895e3bdd788101d1276e48e0d262ebb165afacec1ec4efebcd785/grpcio-1.83.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c834e86d8fd2f03d7e4db49a027f7c5b89c5b88eed305543a5295bd6fee61e40", size = 8000286, upload-time = "2026-07-23T15:19:07.739Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/b0/9a779de2bcda8722501a056fad1bec3d1117977af0c080ab1fc0655fdf35/grpcio-1.83.0-cp310-cp310-win32.whl", hash = "sha256:35a5b1c192496b6c25956eebfa963468935612206fd2543ac3ce981e6a5e0f03", size = 4404616, upload-time = "2026-07-23T15:19:09.988Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/8e/ce9a23590cac33a6c24e6386cc0ffc55821cc13212acc822e98f00a67161/grpcio-1.83.0-cp310-cp310-win_amd64.whl", hash = "sha256:8f6c395e493d20c39b29392ca200e9aaeb78d0bc2f04db0c0a7da7ddc939aa57", size = 5162304, upload-time = "2026-07-23T15:19:11.467Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/f6/3b781cd07a715ea5f5125ae264226e7fc4d87603d6d3955022cabfdc5da2/grpcio-1.83.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:8ff0b8767ddd62704e0d9571c1890af08d84a3a689ebba1807e62519d0b3277f", size = 6338720, upload-time = "2026-07-23T15:19:13.177Z" },
+ { url = "https://files.pythonhosted.org/packages/21/cc/d14833d15d5984e366f1b027fa78bd038c9b028c66880bffb0f5a4d25ee2/grpcio-1.83.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:4772402f43517b4824980be4b3b2274a81eec0004a70009473c31b340d43e223", size = 12178773, upload-time = "2026-07-23T15:19:15.401Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/98/8acbb416544e7871132d8e42a07ed70c802d70e6a16c6009e505a34d32a4/grpcio-1.83.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f4cee5fc86e84a0cf7ad1574b454c3320e087c07f55b7df5dc0ac6a873fb90c0", size = 6921203, upload-time = "2026-07-23T15:19:17.824Z" },
+ { url = "https://files.pythonhosted.org/packages/45/9c/0fdbfaf4fc54e5c88f6bce4008a065092fe7fbc4460eb5617ae8b20fd505/grpcio-1.83.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f5e822a7e7d03282f6ad225e710493c48b9057a353358344a5f7c42b2b37618d", size = 7648508, upload-time = "2026-07-23T15:19:19.685Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/ea/107b9dbb2ed3ad14dd774fd3dde7d29ff9938a6c198654becb2c3a0e9a6a/grpcio-1.83.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f5f410d7c2903eabb34789dfd6342eef04af1ad459943936b7e09a9f5bd417b9", size = 7079466, upload-time = "2026-07-23T15:19:21.478Z" },
+ { url = "https://files.pythonhosted.org/packages/3b/06/9fa9941089e6fae83b060b6ce61c1e81053e52decae43197245f45e07d36/grpcio-1.83.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ee94a4016fdf8699fb1fd8a38652475ff677f1c72074cee44deeeb9a7e95e745", size = 7605583, upload-time = "2026-07-23T15:19:23.74Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/2f/f10fb56062dc2771c630827a82d9ad0ecd05cad572ea3b08d49f6631680a/grpcio-1.83.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c6444666317338e903093c7c756e6cc88eee59f798cb8dd41e87725bf54e1617", size = 8637810, upload-time = "2026-07-23T15:19:25.536Z" },
+ { url = "https://files.pythonhosted.org/packages/99/55/f84927258f6a1b6ea6dea661fdc6de859b35e560c96f3012d15ccd39f85e/grpcio-1.83.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:aa074041231f03959cb097dd5517b0677b8ea49215bae01d5710a7b69dd59969", size = 8008021, upload-time = "2026-07-23T15:19:27.863Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/6b/cdf72161397ccd29d4ca2192f641524536c9cf54ad948c9dd0e0e01138fa/grpcio-1.83.0-cp311-cp311-win32.whl", hash = "sha256:cb056f6e171c42639a50460b2929c82241fda51f71cf3dcdd68090fe45095a45", size = 4404376, upload-time = "2026-07-23T15:19:30.137Z" },
+ { url = "https://files.pythonhosted.org/packages/df/ed/e0ffeb4c848699c194dc9fb6a29ab29bcb2b6aac8c416bf18c51bfe8242c/grpcio-1.83.0-cp311-cp311-win_amd64.whl", hash = "sha256:7416952ca770477990257206276999056f8316d79196f2f25942393e58a20b49", size = 5164469, upload-time = "2026-07-23T15:19:31.941Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "certifi", marker = "python_full_version >= '3.11'" },
+ { name = "h11", marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "anyio", marker = "python_full_version >= '3.11'" },
+ { name = "certifi", marker = "python_full_version >= '3.11'" },
+ { name = "httpcore", marker = "python_full_version >= '3.11'" },
+ { name = "idna", marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "id"
+version = "1.6.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6d/04/c2156091427636080787aac190019dc64096e56a23b7364d3c1764ee3a06/id-1.6.1.tar.gz", hash = "sha256:d0732d624fb46fd4e7bc4e5152f00214450953b9e772c182c1c22964def1a069", size = 18088, upload-time = "2026-02-04T16:19:41.26Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/42/77/de194443bf38daed9452139e960c632b0ef9f9a5dd9ce605fdf18ca9f1b1/id-1.6.1-py3-none-any.whl", hash = "sha256:f5ec41ed2629a508f5d0988eda142e190c9c6da971100612c4de9ad9f9b237ca", size = 14689, upload-time = "2026-02-04T16:19:40.051Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.19"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5f/f7/abb373e5757eaec4b922b92f97ec8d6d7e057cf06778247604fbc4e7c3f3/idna-3.19.tar.gz", hash = "sha256:5e0811a4383b21dc5838069f801c4fb62113b7447663d2530d2bd6e77b49bf15", size = 215237, upload-time = "2026-08-18T05:14:24.27Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "9.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "zipp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a9/01/15bb152d77b21318514a96f43af312635eb2500c96b55398d020c93d86ea/importlib_metadata-9.0.0.tar.gz", hash = "sha256:a4f57ab599e6a2e3016d7595cfd72eb4661a5106e787a95bcc90c7105b831efc", size = 56405, upload-time = "2026-03-20T06:42:56.999Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/38/3d/2d244233ac4f76e38533cfcb2991c9eb4c7bf688ae0a036d30725b8faafe/importlib_metadata-9.0.0-py3-none-any.whl", hash = "sha256:2d21d1cc5a017bd0559e36150c21c830ab1dc304dedd1b7ea85d20f45ef3edd7", size = 27789, upload-time = "2026-03-20T06:42:55.665Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jaraco-classes"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "more-itertools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777, upload-time = "2024-03-31T07:27:34.792Z" },
+]
+
+[[package]]
+name = "jaraco-context"
+version = "6.1.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "backports-tarfile" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/af/50/4763cd07e722bb6285316d390a164bc7e479db9d90daa769f22578f698b4/jaraco_context-6.1.2.tar.gz", hash = "sha256:f1a6c9d391e661cc5b8d39861ff077a7dc24dc23833ccee564b234b81c82dfe3", size = 16801, upload-time = "2026-03-20T22:13:33.922Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f2/58/bc8954bda5fcda97bd7c19be11b85f91973d67a706ed4a3aec33e7de22db/jaraco_context-6.1.2-py3-none-any.whl", hash = "sha256:bf8150b79a2d5d91ae48629d8b427a8f7ba0e1097dd6202a9059f29a36379535", size = 7871, upload-time = "2026-03-20T22:13:32.808Z" },
+]
+
+[[package]]
+name = "jaraco-functools"
+version = "4.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "more-itertools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6c/1f/c23395957d41ccf27c4e535c3d334c4051e5395b3752057ba4cbaec35c56/jaraco_functools-4.6.0.tar.gz", hash = "sha256:880c577ec9720b3a052d5bc611fb9f2269b3d87902ef42440df443b88e443280", size = 20837, upload-time = "2026-07-14T01:28:02.544Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/02/36/ecc85bc96c273dc8a11273ed4782272975e6338d4a3e9228621175edf0e3/jaraco_functools-4.6.0-py3-none-any.whl", hash = "sha256:99e3dc0060c5cbe8fcd1cdb36258e2a65ca40f1566b2033b12abb1bb44dd3c30", size = 11677, upload-time = "2026-07-14T01:28:01.59Z" },
+]
+
+[[package]]
+name = "jeepney"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758, upload-time = "2025-02-27T18:51:01.684Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "joblib"
+version = "1.5.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", hash = "sha256:8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3", size = 331603, upload-time = "2025-12-15T08:41:46.427Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" },
+]
+
+[[package]]
+name = "keyring"
+version = "25.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "importlib-metadata" },
+ { name = "jaraco-classes" },
+ { name = "jaraco-context" },
+ { name = "jaraco-functools" },
+ { name = "jeepney", marker = "sys_platform == 'linux'" },
+ { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" },
+ { name = "secretstorage", marker = "sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" },
+]
+
+[[package]]
+name = "kiwisolver"
+version = "1.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/07/bd78e6a8fae171ea041ef5bba3ed21a003522fa088834b069b1909981f30/kiwisolver-1.5.1.tar.gz", hash = "sha256:f1303ef2eec81262a4b708c3e858afe58d7c75ad91c1c05266eda7673369859a", size = 104395, upload-time = "2026-08-28T10:28:27.153Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/23/54/1b8d2bc580414cc75b3a5b3d195981a6facacd8a8d986e589d0a3b51a709/kiwisolver-1.5.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:1acc7e5b7ef05e9da8bb70cd6c7c4513090213d2e1ad9720f599f0bf6c52aec5", size = 123362, upload-time = "2026-08-28T10:24:43.402Z" },
+ { url = "https://files.pythonhosted.org/packages/57/19/92c30f540dcfff86ff625389427c39b53a9aaea16420ddcc09b2ab8d1073/kiwisolver-1.5.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bad20d4c69c851c982a1e3606f4c293edfd5a87885786c50082412240c4b1ffd", size = 66551, upload-time = "2026-08-28T10:24:44.768Z" },
+ { url = "https://files.pythonhosted.org/packages/30/ae/30b94088722e7bce8b821cd5ee935a87f80023e7243125f1accf98e39bf7/kiwisolver-1.5.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0a4faea5c6db201c6a21391d2ac926ea97acf7dacdbc3c417189e1adb1a00837", size = 64076, upload-time = "2026-08-28T10:24:46.184Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/0e/9f394d693be549fa3fab62498c2778294595991047adc3dcf10aa99b91c0/kiwisolver-1.5.1-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e05c2f7925f1d88778e53cb44f14e0223204a3bdd09a41664750363acfb1f2ef", size = 1628782, upload-time = "2026-08-28T10:24:47.91Z" },
+ { url = "https://files.pythonhosted.org/packages/64/96/26efc04348c0f332b6e6c471dff132bb8b18b2df494a1b65826601674e62/kiwisolver-1.5.1-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3a4e41e3096bf1f0f1b76e2ffd6d828d6547f574f702d59bdbef7acfa59db9c", size = 1228112, upload-time = "2026-08-28T10:24:49.503Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/ac/df9ddc19ec972cd97b60b262dd2c4be28c6192b5a779cad429c6657ee680/kiwisolver-1.5.1-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1d56ec54d257d05e0b50f5780d967540cd07beeaf9e5f645b26d50cce79f4d8", size = 1246756, upload-time = "2026-08-28T10:24:51.225Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/de/c38a246b8a4f4b293c7291aa650917b05c5549b0d532749bc523296e90c4/kiwisolver-1.5.1-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8de6f2a4ce7e7bd27d23dd94abf0ccafe0e0e5cc9c764b0577191f2c25f08f26", size = 1295555, upload-time = "2026-08-28T10:24:52.953Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/48/3c95a5232d8b5783050d8c8089b58bf1f57018f9135232d72c5aa6b0c01b/kiwisolver-1.5.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:16895f553ee6620a827d2da56b871f835fb70b9216cca5d188e885caf6e3bd23", size = 2179476, upload-time = "2026-08-28T10:24:54.568Z" },
+ { url = "https://files.pythonhosted.org/packages/e6/e9/b9e999336afc561b154e93682f597832bdc7446f2ee18b467c5b0e924867/kiwisolver-1.5.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:6b92f60017dda7d877fdc546438b5e28f31c523264f49cf5a48c1d0ce1a0dfbc", size = 2275258, upload-time = "2026-08-28T10:24:56.186Z" },
+ { url = "https://files.pythonhosted.org/packages/76/cd/c1c550796ada4a59644b8264b425fe332686d2a086c4729fcc640ececdfe/kiwisolver-1.5.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:7824b5e8bdbf0bccb4ccd37bbb115849a1dc45437fb4de8351385ed07c437ee0", size = 2443424, upload-time = "2026-08-28T10:24:58.093Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/d4/30f641eb8e10f6ad5bb9af8a15ec8eea386162a6ef491e68995b8680ef4e/kiwisolver-1.5.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:aa7d00b1700966d2917e54d278aba86897890ca9276dd8b76cf6446b6c181b92", size = 2249457, upload-time = "2026-08-28T10:25:00.223Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/d9/211e016f8aa5b5bf496dd3bd7ebab4b73b22d91f025f25e20156a44a77fc/kiwisolver-1.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:96c30002424670b5e1e46495c2b8cbffef39cf77c1d79e76462029d50339785b", size = 70643, upload-time = "2026-08-28T10:25:01.888Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/8e/ae7007266dea1fd93fcc48541042c1f6583958055de3b424a59ec16def25/kiwisolver-1.5.1-cp310-cp310-win_arm64.whl", hash = "sha256:f0f4a42db92d6ec7677ab9d12830a2a8ec145a9c6d15db2b593466bc875c78d7", size = 68215, upload-time = "2026-08-28T10:25:03.136Z" },
+ { url = "https://files.pythonhosted.org/packages/94/7b/2de6908edc668427c149af5f93112e931f87e1fa4cab80bac32c5844dccc/kiwisolver-1.5.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b3d78f7bb2b9d9a30345be1474b9aaa8685430b54afb51ba3639b5c6c11e9ed6", size = 123364, upload-time = "2026-08-28T10:25:04.359Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/24/e70914415c77c97be7e22c80a0740869cb7428768cc380fdcdf6703e7084/kiwisolver-1.5.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5025e36fb4fb275cef0a4e30dbb11cb4ae61d1c83deb90189cb5d7e4cafd6b55", size = 66558, upload-time = "2026-08-28T10:25:05.506Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/2b/8b08b11833db4d475b8ef1f36174f8d8a7abd31bedd7e794be78e8814b48/kiwisolver-1.5.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc1a26b8e53395a01c2c611e58602fa47461f136fba7cd5542e6db6d64be1839", size = 64071, upload-time = "2026-08-28T10:25:06.7Z" },
+ { url = "https://files.pythonhosted.org/packages/89/00/05c2d0369ac322d22d5c05f84b5c4a6856fa6207fbae42869108a28f0383/kiwisolver-1.5.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:95a02752aa032eef4aed01cda6d9b687c669bd0396bf4519eef8bba22a286720", size = 1438206, upload-time = "2026-08-28T10:25:08.254Z" },
+ { url = "https://files.pythonhosted.org/packages/c0/05/c941a139f27438c1910d630fdc3ccfdab7c8407c72052299ead12ece086e/kiwisolver-1.5.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:719a35fa1156db3640555f95ebb94f60a444e64d1c69626b0edef5df78eba225", size = 1248975, upload-time = "2026-08-28T10:25:10.053Z" },
+ { url = "https://files.pythonhosted.org/packages/58/a1/2669ee5512e39b9d4de25faacaedf788c957f93730c5f7c63993ec4f5933/kiwisolver-1.5.1-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:febcce10f2bcdbb80b4ea919238a6a4ac13dbc4c7cadbe8d5d75c3682f8b5404", size = 1266301, upload-time = "2026-08-28T10:25:11.754Z" },
+ { url = "https://files.pythonhosted.org/packages/28/b8/353f52f2c7f861a9e90cd2e8f90f85b3ad03060835f823e08298d094c463/kiwisolver-1.5.1-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1d852545c4d0e35a72728d072cbaa59e2fa7dd84bdf01e068d670dd0ceb58eb6", size = 1319708, upload-time = "2026-08-28T10:25:13.559Z" },
+ { url = "https://files.pythonhosted.org/packages/21/0e/14b83200eadc2c1d63b76bac01c1813bf072aecf567429f303e00b70258e/kiwisolver-1.5.1-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:2e10ae1bba1899188b33557c10d73affcc12033edd18adddb57d209039976a4c", size = 971720, upload-time = "2026-08-28T10:25:14.934Z" },
+ { url = "https://files.pythonhosted.org/packages/86/91/9d43d84d23b1cbff72a142d387ead1ea03db0cba8ff86ed5335addad3cc9/kiwisolver-1.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b69602970994a2ed8bbfa78c2f0394a7435226c6040489702d9f0a0ad0c07052", size = 2200119, upload-time = "2026-08-28T10:25:16.636Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/7c/f2bd9616f27ffb5e17cecc0baa5d0bbcee7e55aeddc0ccc871d69e2fc3ee/kiwisolver-1.5.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d50de98e8d807dc31822fff96f50293163a62418eb65487a21b42713d72ed0b7", size = 2295005, upload-time = "2026-08-28T10:25:18.374Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/17/ee671b72bf8f46a08379d4392c65582541759a542428197562f2898294ad/kiwisolver-1.5.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3221f78211074f561c44ca42eac0619828171bec15a2c4cf6f7747d07df76e8e", size = 1960982, upload-time = "2026-08-28T10:25:19.893Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/f7/0e26b4c05bee3bdb0f048dfa305e4fe701999ea17b51e9c616ef91035bbe/kiwisolver-1.5.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0ba9527afc80ae3d7814ed98b6572d02bf85eaf48065678342c5f0c6dab7a8c7", size = 2464918, upload-time = "2026-08-28T10:25:21.65Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/62/6eb431133d30ce656ac1e5ff72fac70dd34d54c3984f4011b9ac8bf77d54/kiwisolver-1.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e12dfea7f5fc2a34a9080efbf79c4c44eb380ec5b9c6fea09407e08f0d1e941d", size = 2270967, upload-time = "2026-08-28T10:25:23.643Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/9f/6f9e489c188200e6fb3193935501894811e8c97577c8ffe9033589bf3521/kiwisolver-1.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:1a7587dc335f2c0f5bd577fd0540bd16c66006bdb60f759a1059f025e6c4f071", size = 70744, upload-time = "2026-08-28T10:25:25.061Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/6d/dfc430d1d43957061599adea3f08ea982bb6f4ab601a8c974bedcf2ba850/kiwisolver-1.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:e4e4523d6f336708d732516e6cfca7796cf3d96c9474eb5aecf6165f2f1fefc3", size = 68404, upload-time = "2026-08-28T10:25:26.186Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/f1/8bae9fac0f1837679ed59a5dd7e97e7eb943b738defa7cc0117ea0d107dc/kiwisolver-1.5.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a5716a33bfabb2c6ce27b6cf03253467b3804f83e215f4d202685cf93c6c9874", size = 59543, upload-time = "2026-08-28T10:28:13.794Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/3e/42e3639d32ef3ac6ede80c39dc1d1df6224927409960d8f762b6cb504efe/kiwisolver-1.5.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:685929988b208a911f1285e2f8ed54210b0d681a3dc0f03e00d599d291986e7e", size = 57504, upload-time = "2026-08-28T10:28:15.074Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/12/f4beaaceb740b96c363a8fa6f34dbdf37a58d9e5f15416427d7bf89c552a/kiwisolver-1.5.1-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e4e49f7e1a4e7191bdf9dc67a974db714501b1fc52c24324103d06a86abd5c08", size = 79885, upload-time = "2026-08-28T10:28:16.345Z" },
+ { url = "https://files.pythonhosted.org/packages/02/24/18d8a755acdae79c37ca2f1a925795aab67b9456c30c8569c377ea3abc77/kiwisolver-1.5.1-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f0a887b6565bbfe80efde2b7f6e8890d7d9bbdb11bdb17028a3690c32fe0621f", size = 77582, upload-time = "2026-08-28T10:28:17.719Z" },
+ { url = "https://files.pythonhosted.org/packages/df/a9/b86dde4f553ef74db0f9c32398614e24b2e8ec1d29a6ca04ae080d7dd29b/kiwisolver-1.5.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1983f0974a750a6f6556f368ba11105d1d8369c735b944747c9f12ae5aea7aae", size = 98321, upload-time = "2026-08-28T10:28:19.087Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/1d/59ba570b1774e95e97fde3a0981b2e22118a7a495f73bf74cedc538566a0/kiwisolver-1.5.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:416ba7ff9f233b7036689bb5a3783537e838ad483f63558d2a800f75afe738b1", size = 59450, upload-time = "2026-08-28T10:28:20.383Z" },
+ { url = "https://files.pythonhosted.org/packages/22/98/a6849f04dc18b5400e8b98affa2cd8fd86ed583085f036e57b32e571f4fa/kiwisolver-1.5.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:8af9b142ad719ae3a911ebf616bc4b78b32bbab84d6a40d3ad2f129670509957", size = 57400, upload-time = "2026-08-28T10:28:21.632Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/ce/a7dc71353dd06a4cbe02222773f52d4a28c81e5a452a75797f8ed113dc99/kiwisolver-1.5.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5daa1f19e097050b9c4d9a78fcc9263cb96c9dfae08037ddc1b7c4ad1889f2a2", size = 79891, upload-time = "2026-08-28T10:28:22.936Z" },
+ { url = "https://files.pythonhosted.org/packages/10/b1/d61c61a84ff85d1a36a99df2c152b59ffedb1d356c598902aba44abcdb60/kiwisolver-1.5.1-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cdaeeb6c350106df6bf9d873395973e5f066a9713200b72cd64f55d0a3eafab6", size = 77605, upload-time = "2026-08-28T10:28:24.322Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/52/5aef56f21a460a6e43ab3cdfc7697d59d7b87deb0ec97a0f7b91aa4a521b/kiwisolver-1.5.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:17851e5dad4484be0cbccbde3b15331deae036de9aebd45eed964487802b172f", size = 98465, upload-time = "2026-08-28T10:28:25.696Z" },
+]
+
+[[package]]
+name = "llvmlite"
+version = "0.49.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/27/72ae94ea5c8f7349ec1c229d4cd058feb799cbd0833ad6d1b47c919b37b7/llvmlite-0.49.0.tar.gz", hash = "sha256:00f16db782f4a13c78c5804aedc434e46794a77e89999a168f9401106270e50a", size = 194467, upload-time = "2026-08-11T16:26:00.489Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e0/0d/daceb212c44cad1115b2d05dd55beafe23ff06627344adb4ded0c661bb1a/llvmlite-0.49.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:ee81e96c15a6f870918f1eb60c913551c16aa23defb4f5f1acfa660d6a0aaac2", size = 40479229, upload-time = "2026-08-11T16:22:56.104Z" },
+ { url = "https://files.pythonhosted.org/packages/72/2c/eb42378b4f3afc71f9fe172d01f30135dc1d54c7fd95cf76d5445d6f7809/llvmlite-0.49.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:854941c2267fd4fc5b2ce02b8af8ecdffa79fb7784591d3a89370322039ea09f", size = 59890659, upload-time = "2026-08-11T16:23:03.359Z" },
+ { url = "https://files.pythonhosted.org/packages/4f/dc/fe880ac1eb93c09b6c9a0539ad18c98778386978a0e20a13a55788044ad2/llvmlite-0.49.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da7b64474ac15ca595efa2644d5c6836638ccf70709fad3aba3fc56a55966928", size = 58344482, upload-time = "2026-08-11T16:23:12.122Z" },
+ { url = "https://files.pythonhosted.org/packages/59/f6/5c18be29145cfca1d9e859e55a3c586a8c5a821825017b04c7999cd166c9/llvmlite-0.49.0-cp310-cp310-win_amd64.whl", hash = "sha256:b352c14353330c879e339b8f8d7491d565fe94242697714a24e80bd757202384", size = 41865252, upload-time = "2026-08-11T16:23:20.532Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/d0/ab52de2328e97ca96cdf0331a5f774796bddc420a51768f4501193f80cbb/llvmlite-0.49.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:4b0e710880b7cc910392bd6b9f1bbf468fed99b182e4420d51598f36114b3dce", size = 40479230, upload-time = "2026-08-11T16:23:28.744Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/80/0989432d12b7c86a6f5f380eb92eca7de779af9b34dedbd311b694d7da8d/llvmlite-0.49.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a8c0fc9d624bdc30a3d2db11eb2fb98f80fb209d20b37604eda516cd9b699cf4", size = 59890659, upload-time = "2026-08-11T16:23:37.346Z" },
+ { url = "https://files.pythonhosted.org/packages/58/e9/76859ca36aaa460b6ae0508e01637f0e9bdb9b59faaa4637ade3b94bbcca/llvmlite-0.49.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20496a5c9fdb8179fb9300e7d19f6782555d98aeeb4a322264aa7fd99f980618", size = 58344482, upload-time = "2026-08-11T16:23:44.199Z" },
+ { url = "https://files.pythonhosted.org/packages/7d/49/47cd23e05d52d117b6119871ec299adedc9d8d332a2296964d9b2adc06d9/llvmlite-0.49.0-cp311-cp311-win_amd64.whl", hash = "sha256:6a5b06c1b5fc4ae4c9b169b065f42b719448ef1f873687ef224ef69969b75ec3", size = 41865253, upload-time = "2026-08-11T16:23:50.198Z" },
+]
+
+[[package]]
+name = "markdown"
+version = "3.10.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/29/6f/da4c6aea59b3001f2e8c0ec7497475aadaf3b021c10cab5b2858f0f32b26/markdown-3.10.3.tar.gz", hash = "sha256:3589362618f743188b4d955b874402bc814f4f83f544dc207719f4baa7d9c45f", size = 372596, upload-time = "2026-07-30T19:05:29.005Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/64/69/4a5af2bc115a9a33fefe51709749de8262be3f9ba063d1753a837cdbc49c/markdown-3.10.3-py3-none-any.whl", hash = "sha256:fa6c92a00a4a3c98b22728c64a935ae1928250ae65058a6ded814d2cc29a4cea", size = 110757, upload-time = "2026-07-30T19:05:27.883Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" },
+ { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" },
+ { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" },
+ { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" },
+ { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" },
+ { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" },
+ { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
+ { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
+ { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
+ { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
+ { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
+ { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.10.9"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version < '3.11' and sys_platform == 'win32'",
+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version < '3.11' and sys_platform == 'darwin'",
+]
+dependencies = [
+ { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+ { name = "cycler", marker = "python_full_version < '3.11'" },
+ { name = "fonttools", marker = "python_full_version < '3.11'" },
+ { name = "kiwisolver", marker = "python_full_version < '3.11'" },
+ { name = "numpy", marker = "python_full_version < '3.11'" },
+ { name = "packaging", marker = "python_full_version < '3.11'" },
+ { name = "pillow", marker = "python_full_version < '3.11'" },
+ { name = "pyparsing", marker = "python_full_version < '3.11'" },
+ { name = "python-dateutil", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/63/1b/4be5be87d43d327a0cf4de1a56e86f7f84c89312452406cf122efe2839e6/matplotlib-3.10.9.tar.gz", hash = "sha256:fd66508e8c6877d98e586654b608a0456db8d7e8a546eb1e2600efd957302358", size = 34811233, upload-time = "2026-04-24T00:14:13.539Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/18/6f/340b04986e67aac6f66c5145ce68bf72c64bed30f92c8913499a6e6b8f99/matplotlib-3.10.9-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77210dce9cb8153dffc967efaae990543392563d5a376d4dd8539bebcb0ed217", size = 8296625, upload-time = "2026-04-24T00:11:43.376Z" },
+ { url = "https://files.pythonhosted.org/packages/bb/2f/127081eb83162053ebb9678ceac64220b93a663e0167432566e9c7c82aab/matplotlib-3.10.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1e7698ac9868428e84d2c967424803b2472ff7167d9d6590d4204ed775343c3b", size = 8188790, upload-time = "2026-04-24T00:11:46.556Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/b7/d8bcec2626c35f96972bff656299fef4578113ea6193c8fdad324710410c/matplotlib-3.10.9-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1aa972116abb4c9d201bf245620b433726cb6856f3bef6a78f776a00f5c92d37", size = 8769389, upload-time = "2026-04-24T00:11:48.959Z" },
+ { url = "https://files.pythonhosted.org/packages/12/49/b78e214a527ea732033b7f4d37f7afb504d74ba9d134bd47938230dfb8b1/matplotlib-3.10.9-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae2f11957b27ce53497dd4d7b235c4d4f1faf383dfb39d0c5beb833bff883294", size = 9589657, upload-time = "2026-04-24T00:11:51.915Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/15/5246f7b43beae19c74dfee651d58d6cc8112e06f77adb4e88cc04f2e3a23/matplotlib-3.10.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b049278ddce116aaa1c1377ebf58adea909132dfce0281cf7e3a1ea9fc2e2c65", size = 9651983, upload-time = "2026-04-24T00:11:54.766Z" },
+ { url = "https://files.pythonhosted.org/packages/75/77/5acecfe672ba0fa1b8c0454f69ce155d1e6fc5852fa7206bf9afaf767121/matplotlib-3.10.9-cp310-cp310-win_amd64.whl", hash = "sha256:82834c3c292d24d3a8aae77cd2d20019de69d692a34a970e4fdb8d33e2ea3dda", size = 8199701, upload-time = "2026-04-24T00:11:58.389Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/8c/290f021104741fea63769c31494f5324c0cd249bf536a65a4350767b1f22/matplotlib-3.10.9-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:68cfdcede415f7c8f5577b03303dd94526cdb6d11036cecdc205e08733b2d2bb", size = 8306860, upload-time = "2026-04-24T00:12:01.207Z" },
+ { url = "https://files.pythonhosted.org/packages/51/18/325cd32ece1120d1da51cc4e4294c6580190699490183fc2fe8cb6d61ec5/matplotlib-3.10.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfca0129678bd56379db26c52b5d77ed7de314c047492fbdc763aa7501710cfb", size = 8199254, upload-time = "2026-04-24T00:12:04.239Z" },
+ { url = "https://files.pythonhosted.org/packages/79/db/e28c1b83e3680740aa78925f5fb2ae4d16207207419ad75ea9fe604f8676/matplotlib-3.10.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e436d155fa8a3399dc62683f8f5d0e2e50d25d0144a73edd73f82eec8f4abfb", size = 8777092, upload-time = "2026-04-24T00:12:06.793Z" },
+ { url = "https://files.pythonhosted.org/packages/55/fa/3ce7adfe9ba101748f465211660d9c6374c876b671bdb8c2bb6d347e8b94/matplotlib-3.10.9-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56fc0bd271b00025c6edfdc7c2dcd247372c8e1544971d62e1dc7c17367e8bf9", size = 9595691, upload-time = "2026-04-24T00:12:09.706Z" },
+ { url = "https://files.pythonhosted.org/packages/36/c4/6960a76686ed668f2c60f84e9799ba4c0d56abdb36b1577b60c1d061d1ec/matplotlib-3.10.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5a6104ed666402ba5106d7f36e0e0cdca4e8d7fa4d39708ca88019e2835a2eb", size = 9659771, upload-time = "2026-04-24T00:12:12.766Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/0d/271aace3342157c64700c9ff4c59c7b392f3dbab393692e8db6fbe7ab96c/matplotlib-3.10.9-cp311-cp311-win_amd64.whl", hash = "sha256:d730e984eddf56974c3e72b6129c7ca462ac38dc624338f4b0b23eb23ecba00f", size = 8205112, upload-time = "2026-04-24T00:12:15.773Z" },
+ { url = "https://files.pythonhosted.org/packages/e2/ee/cb57ad4754f3e7b9174ce6ce66d9205fb827067e48a9f58ac09d7e7d6b77/matplotlib-3.10.9-cp311-cp311-win_arm64.whl", hash = "sha256:51bf0ddbdc598e060d46c16b5590708f81a1624cefbaaf62f6a81bf9285b8c80", size = 8132310, upload-time = "2026-04-24T00:12:18.645Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/2b/0e92ad0ac446633f928a1563db4aa8add407e1924faf0ded5b95b35afb27/matplotlib-3.10.9-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1872fb212a05b729e649754a72d5da61d03e0554d76e80303b6f83d1d2c0552b", size = 8293058, upload-time = "2026-04-24T00:13:56.339Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/23/74682fd369f5299ceda438fea2a0662e6383b85c9383fb9cdfcf04713e07/matplotlib-3.10.9-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:985f2238880e2e69093f588f5fe2e46771747febf0649f3cf7f7b7480875317f", size = 8186627, upload-time = "2026-04-24T00:13:58.623Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/e8/368aab88f3c4cd8992800f31abfe0670c3e47540ba20a97e9fdbcde594b3/matplotlib-3.10.9-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6640f75af2c6148293caa0a2b39dd806a492dd66c8a8b04035813e33d0fd2585", size = 8764117, upload-time = "2026-04-24T00:14:01.684Z" },
+ { url = "https://files.pythonhosted.org/packages/63/e2/9f66ca6a651a52abfe0d4964ce01439ed34f3f1e119de10ff3a07f403043/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:42fb814efabe95c06c1994d8ab5a8385f43a249e23badd3ba931d4308e5bca20", size = 8304420, upload-time = "2026-04-24T00:14:04.57Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/e8/467c03568218792906aa87b5e7bb379b605e056ed0c74fe00c051786d925/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f76e640a5268850bfda54b5131b1b1941cc685e42c5fa98ed9f2d64038308cba", size = 8197981, upload-time = "2026-04-24T00:14:07.233Z" },
+ { url = "https://files.pythonhosted.org/packages/6f/87/afead29192170917537934c6aff4b008c805fff7b1ccea0c79120d96beda/matplotlib-3.10.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3fc0364dfbe1d07f6d15c5ebd0c5bf89e126916e5a8667dd4a7a6e84c36653d4", size = 8774002, upload-time = "2026-04-24T00:14:09.816Z" },
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.11.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version >= '3.11' and sys_platform == 'win32'",
+ "python_full_version >= '3.11' and sys_platform == 'emscripten'",
+ "python_full_version >= '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version >= '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version >= '3.11' and sys_platform == 'darwin'",
+]
+dependencies = [
+ { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+ { name = "cycler", marker = "python_full_version >= '3.11'" },
+ { name = "fonttools", marker = "python_full_version >= '3.11'" },
+ { name = "kiwisolver", marker = "python_full_version >= '3.11'" },
+ { name = "numpy", marker = "python_full_version >= '3.11'" },
+ { name = "packaging", marker = "python_full_version >= '3.11'" },
+ { name = "pillow", marker = "python_full_version >= '3.11'" },
+ { name = "pyparsing", marker = "python_full_version >= '3.11'" },
+ { name = "python-dateutil", marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/49/64/f9a391af28f518b11ad45a8a712353c94a0aefce09d3703200e5c54b610a/matplotlib-3.11.1.tar.gz", hash = "sha256:69647db5746941c793d6e445a4cd349323ffb87d9cc958c2ad84a659b4832d30", size = 32612045, upload-time = "2026-07-18T03:39:46.63Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/6e/d0/791aa183dd88491555cf7d4be0b52b0bcf6c3c2a2c22c815a2e819bf53e2/matplotlib-3.11.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:b7cf158e7add54a8d51ac9b5a84abd6d4e13ed4951b4f25f1c5139f41c2addb2", size = 9440302, upload-time = "2026-07-18T03:38:03.844Z" },
+ { url = "https://files.pythonhosted.org/packages/35/74/82bbdf683a301f4478384c8aaba6903631a2ca18294b2d7655c9a542bffb/matplotlib-3.11.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d2ace7273b9a5061a3b420918a16fae1f2dc5dfee1abcc13aba71b5d94b1820c", size = 9268549, upload-time = "2026-07-18T03:38:06.144Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/f0/9b4298911303f74e6d83e64a81d996c0616405ec95046fac7f17e4258b9e/matplotlib-3.11.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee55e9041211bf84302ab55ec3965df18dd90ae19f8b58332a7feaf208bfe83", size = 10024922, upload-time = "2026-07-18T03:38:08.236Z" },
+ { url = "https://files.pythonhosted.org/packages/84/6f/0bc3c3d05b021db44c14bc379a7c0df7d57302aa15380c16fd4e63fd6a9b/matplotlib-3.11.1-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f4bdeea33a8d15a071dbfe6d119451b1d719c733ac666d65357082901a9099", size = 10832170, upload-time = "2026-07-18T03:38:10.276Z" },
+ { url = "https://files.pythonhosted.org/packages/db/4d/e375f39acdb2af5a9342730618608e39790ec842e6f1b392863028781459/matplotlib-3.11.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b4c78ceb2f11bcac7389d305cda17aeb1f4586a857854ab5780bd3dd8dbfc407", size = 10916701, upload-time = "2026-07-18T03:38:12.512Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/be/fa26ed085b41298f64a8f9b7592c671bbf1acc8b0df124c1c5de96b859f8/matplotlib-3.11.1-cp311-cp311-win_amd64.whl", hash = "sha256:7f33a781e12b1e53b278deb2f5373c2e55ec4f10727be3440c0cfb5cda9f944f", size = 9315331, upload-time = "2026-07-18T03:38:14.949Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/f3/eb5bdf3b6e191b200db298b08bbc1638b7f3c82cdc8680f9d88bf72559ae/matplotlib-3.11.1-cp311-cp311-win_arm64.whl", hash = "sha256:67e4c3cd578c65ebd81bdc09a1b6592ceafee6dfafe116dc85dfcb647b5bbb18", size = 9003475, upload-time = "2026-07-18T03:38:17.205Z" },
+ { url = "https://files.pythonhosted.org/packages/ee/38/ceb1d637c4db6d06141f3739e93af3321e7caaabe69b57ae48ffe3ee95b1/matplotlib-3.11.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:427258425f9a3fc4ed79a91f9e9b9aaf5a82cb6571e85dc14063cc6fbb993741", size = 9438045, upload-time = "2026-07-18T03:39:39.491Z" },
+ { url = "https://files.pythonhosted.org/packages/89/25/72ad8b58602d3a6ef1dfc4b65ecd01634ab65a2bdf494c9fe0e966dbf081/matplotlib-3.11.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:1ac697e591c11b6ad04679a73c2d2f9980fe9d9f0311fb414a2e329706343dfb", size = 9266127, upload-time = "2026-07-18T03:39:41.597Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/6d/69552382fcc8e93d1f2763ef2665980a900a48b7f3a4c57ed290726d1cbc/matplotlib-3.11.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e4b9ac2f1f607ecda2af90a5232beee2af7582fce1cc30c4b6a1b012dc21ee99", size = 10019439, upload-time = "2026-07-18T03:39:43.78Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "more-itertools"
+version = "11.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/1d/f4da6f02cdffe04d6362210b807146a26044c88d839208aec273bb0d9184/more_itertools-11.1.0.tar.gz", hash = "sha256:48e8f4d9e7e5878571ecf6f2b4e57634f93cd474cc8cfbd2376f2d11b396e30d", size = 145772, upload-time = "2026-05-22T14:14:29.909Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e8/3d/1087453384dbde46a8c7f9356eead2c58be8a7bf156bca40243377c85715/more_itertools-11.1.0-py3-none-any.whl", hash = "sha256:4b65538ae22f6fed0ce4874efd317463a7489796a0939fa66824dd542125a192", size = 72226, upload-time = "2026-05-22T14:14:28.824Z" },
+]
+
+[[package]]
+name = "mpmath"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" },
+]
+
+[[package]]
+name = "narwhals"
+version = "2.25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/7b/6248dada39781db1ab3ebf08943080df0796098515a87f6f8696d14ec744/narwhals-2.25.0.tar.gz", hash = "sha256:62c036c810662bf7820b7737077176313bc59350eeeefb808510f388c743e4b2", size = 677076, upload-time = "2026-08-20T18:10:15.454Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/eb/dc/55481808fd70ef1567cf13540ffd4702af3f74b112e35427564b03f79c2d/narwhals-2.25.0-py3-none-any.whl", hash = "sha256:1f0f403e8c7e4463cde9bfe78b12fdd809e3ae3dda6d9b2f802934fb9c7a6a8f", size = 467373, upload-time = "2026-08-20T18:10:13.834Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.4.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version < '3.11' and sys_platform == 'win32'",
+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version < '3.11' and sys_platform == 'darwin'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368, upload-time = "2024-10-21T12:39:38.695Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263, upload-time = "2024-10-21T12:39:36.247Z" },
+]
+
+[[package]]
+name = "networkx"
+version = "3.6.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version >= '3.11' and sys_platform == 'win32'",
+ "python_full_version >= '3.11' and sys_platform == 'emscripten'",
+ "python_full_version >= '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version >= '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version >= '3.11' and sys_platform == 'darwin'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" },
+]
+
+[[package]]
+name = "nh3"
+version = "0.3.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/2f/022b27146d52d24b1b353b003359134788ecbcd6fcdf6283adbd57c0fbc8/nh3-0.3.7.tar.gz", hash = "sha256:71860d01c16f4d8c72e334e0674beb2b0899dbd0bf760de18932ef4390303848", size = 25662, upload-time = "2026-08-23T14:26:30.728Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/94/0d/c257754bf57f829f307aa226bbe136d3a1356b5a0d08324c7b6bd2a8aacd/nh3-0.3.7-cp38-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:6c3aa50eb26e9228238271db9f983cbc3b006dfbfeca2d4dc34c33ddc6ac5ea5", size = 1493959, upload-time = "2026-08-23T14:26:09.025Z" },
+ { url = "https://files.pythonhosted.org/packages/07/42/a687e7091928806e514f89fa2666f25ec9bfe0a902fc4402b25e51ce408b/nh3-0.3.7-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f266d3f1b3647449923a8e406524632220dd5d8b647078dfe45b885d33d10479", size = 859615, upload-time = "2026-08-23T14:26:10.606Z" },
+ { url = "https://files.pythonhosted.org/packages/85/05/b0e6bef633549a23347d5462aa288fcc42381e7918482062ca3cb456242a/nh3-0.3.7-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e8fd1ab205258b29254f72db377d99e2c96aa7653ef3b015ccab0420b094b506", size = 839872, upload-time = "2026-08-23T14:26:12.037Z" },
+ { url = "https://files.pythonhosted.org/packages/17/40/2a0921d45b20828708bcb56887e47dcf8cae13818de5bf9a01308d348712/nh3-0.3.7-cp38-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:19f288c938ec6eef1f5d2c6cab47838e71fef8097e1c1233802be5a6230ba086", size = 1091325, upload-time = "2026-08-23T14:26:13.34Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/d1/9d70e0e418a48280ec0ddc6c1b08b4b1136ebcc31a1625e57ff5c665fa51/nh3-0.3.7-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de2b2aab32ea303405debefdcfc58043d3e635fa3f67b9eb140d2b0e0c0d2563", size = 1042482, upload-time = "2026-08-23T14:26:14.667Z" },
+ { url = "https://files.pythonhosted.org/packages/93/a7/02dd159d4e71f98607d8d4249cddb7561e77be1a8e4dec77d76e1b68fc99/nh3-0.3.7-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b7279d43323a25225df23576af6594a16693f61431170848b8b2ac21ad4f174", size = 946868, upload-time = "2026-08-23T14:26:16.094Z" },
+ { url = "https://files.pythonhosted.org/packages/a6/ed/c5510c615dce55b6fcc364aa1838142f938beed64f5e4927490dfcaf4405/nh3-0.3.7-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70f5ac8626e899a4bab0ef74ca2f5bd602f49c7b739e6e5026b4afc6d63dac42", size = 832161, upload-time = "2026-08-23T14:26:17.272Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/e3/3212c1a5b5745245d7f18885207bbddb34c56075f34dd682bd539aad55cc/nh3-0.3.7-cp38-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:5ffdfcb9a686ffb12765376bcfb6b5b55728516d3c0ee317d29982381ded3df8", size = 849791, upload-time = "2026-08-23T14:26:18.498Z" },
+ { url = "https://files.pythonhosted.org/packages/20/64/9e36594efad6c290de4240d02cb2bd80c339a4ab1c4de66e599ffa6d9d81/nh3-0.3.7-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bc42bb1193c1e28a1e74c2cabaca178e118a7103e8832699fef8a2b3e2496493", size = 875473, upload-time = "2026-08-23T14:26:19.908Z" },
+ { url = "https://files.pythonhosted.org/packages/00/0c/1a8985fd43fea5530c0ac890b6f0b423770ee72f111b70b7a77f2dec243a/nh3-0.3.7-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d56e76bd3cadb09b6b0cef364850811663734b348a25f5f587a2819c495367bd", size = 1036463, upload-time = "2026-08-23T14:26:21.536Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/5d/891e533b716cf00df76ad0ba6485dcfd14d59a6430a3cc99057c4c04004e/nh3-0.3.7-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:fd4a70efb45d5372174f718878eb7a35c12677626a63b2f103b23b833457dcac", size = 1116029, upload-time = "2026-08-23T14:26:22.907Z" },
+ { url = "https://files.pythonhosted.org/packages/42/e5/ae8c0782fce74fb6fcf7234bb3d4017f37ce181b4f9d29369eab21c50a04/nh3-0.3.7-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:15f5fbf090f5c88d61c820e1fc1fceecb6520cca9fe85649c06b57ef9dc9ff62", size = 1076589, upload-time = "2026-08-23T14:26:24.302Z" },
+ { url = "https://files.pythonhosted.org/packages/26/a4/c3423351e8d864ad756e85e15f0c01433361f14d34e4ed156482c0518f2a/nh3-0.3.7-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6698a822132beedab80f131c08d8d0ac5a178ddeb488d02ca4b67716ecfac7af", size = 1058871, upload-time = "2026-08-23T14:26:25.674Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/6a/478f153f1d7c0baaa3d1e8bb5fdcee3a6235f90fe44ea969a9d4e2b8c47a/nh3-0.3.7-cp38-abi3-win32.whl", hash = "sha256:6e4280115d44c3b278eef712a86748c1a723105cd79feec46952383117ab4e59", size = 630729, upload-time = "2026-08-23T14:26:26.932Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/b9/34433ccb1f0fe6968dabbb7d4bf5721c6221878ef07832748c06655a6a80/nh3-0.3.7-cp38-abi3-win_amd64.whl", hash = "sha256:618e3059caf41ccdf5dcccb3fa9df4cf6e4efe23d1382a8bbfca272a8a4f8bfc", size = 644462, upload-time = "2026-08-23T14:26:28.294Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/70/e140dffff6e808dc6343598df76e7e2407fd0f581de3524c75fba2e0cf24/nh3-0.3.7-cp38-abi3-win_arm64.whl", hash = "sha256:f04b7d333b27f13ca439da3cf1c75c2fba34f104969f6ce4ac8e7079699c2f4a", size = 621867, upload-time = "2026-08-23T14:26:29.547Z" },
+]
+
+[[package]]
+name = "numba"
+version = "0.67.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "llvmlite" },
+ { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7a/90/2544f4e3a61e501d6c9a5418fd4b905323222693d54a02cab0106a0af865/numba-0.67.0.tar.gz", hash = "sha256:cd75aa535b33fa05d9d930b1ae8af9f97a2881e96d72dfb38ec9b78284d9f851", size = 2836515, upload-time = "2026-08-11T23:04:00.174Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/af/2e/6e72b3edbb7c7d6b44b2ca9e1b62e91997415d181541ef47fc6957c59bf2/numba-0.67.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:8c0e88acd4341ddf40779db3c0228b9188aca7fcab5f5f3ce9949a1fc71e9a02", size = 2745135, upload-time = "2026-08-11T23:03:08.321Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/17/5358f24235ef1a5a80b7e28f3e1baa886c0bcf07dc68557009284e6ba698/numba-0.67.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6c8e9ba3f9602471e8c6f563ffcce8db8046741f0bafb782a052e41dc6b6861", size = 3821881, upload-time = "2026-08-11T23:03:11.172Z" },
+ { url = "https://files.pythonhosted.org/packages/0e/18/2f00694248e32c53812baf3d36a7c656dbdd667c6993087b3da068f74b02/numba-0.67.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:694c81c6560b2b47e5fc1dc39c29175b907adf862d9af0af801453400a022a61", size = 3528397, upload-time = "2026-08-11T23:03:13.107Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/39/4175b074929938011bd4b564beb4e0fcffd46252e01f60602b57ffb02b06/numba-0.67.0-cp310-cp310-win_amd64.whl", hash = "sha256:ed333e0af4386294e7f03e550e01411856b6935e717d859225e0a7338c6b6795", size = 2815861, upload-time = "2026-08-11T23:03:15.072Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/ed/55ba4e54ee878396de6b18e6533cc4a92fa519e8c82d55cf40f98c0a6831/numba-0.67.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:3fa3d1b27f96f2c0d54513d953d7197886aa1eaa7d2439a0eedc44d993fb181a", size = 2744821, upload-time = "2026-08-11T23:03:17.321Z" },
+ { url = "https://files.pythonhosted.org/packages/be/78/3f3c45dbaec3cf02bbb1825731beca50f591227e95143d6bd7a64897641c/numba-0.67.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8c80c847301dc33dc8f84a97a952004023d9a05578ae4512b087176264cc1960", size = 3827182, upload-time = "2026-08-11T23:03:19.684Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/24/4e70cb86534283d859c3aea2302da523e41539b98dd6c3c4d0a42af95cda/numba-0.67.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e7a7b0121466f1e9a8a074b0545fe90e16389623abf979b5d7c299dca1294d7e", size = 3532817, upload-time = "2026-08-11T23:03:22.06Z" },
+ { url = "https://files.pythonhosted.org/packages/26/4d/23dab7f4233be0fc34f54a169ed85238467cd24d8adf2498e5c12ea19dc7/numba-0.67.0-cp311-cp311-win_amd64.whl", hash = "sha256:cfba1ac34f0363fb1a250a10e97240780d11e05227892f7286b26fbfd0ad58ce", size = 2815700, upload-time = "2026-08-11T23:03:23.812Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "1.26.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/6e/09db70a523a96d25e115e71cc56a6f9031e7b8cd166c1ac8438307c14058/numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010", size = 15786129, upload-time = "2024-02-06T00:26:44.495Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a7/94/ace0fdea5241a27d13543ee117cbc65868e82213fb31a8eb7fe9ff23f313/numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0", size = 20631468, upload-time = "2024-02-05T23:48:01.194Z" },
+ { url = "https://files.pythonhosted.org/packages/20/f7/b24208eba89f9d1b58c1668bc6c8c4fd472b20c45573cb767f59d49fb0f6/numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a", size = 13966411, upload-time = "2024-02-05T23:48:29.038Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/a5/4beee6488160798683eed5bdb7eead455892c3b4e1f78d79d8d3f3b084ac/numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4", size = 14219016, upload-time = "2024-02-05T23:48:54.098Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/d7/ecf66c1cd12dc28b4040b15ab4d17b773b87fa9d29ca16125de01adb36cd/numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f", size = 18240889, upload-time = "2024-02-05T23:49:25.361Z" },
+ { url = "https://files.pythonhosted.org/packages/24/03/6f229fe3187546435c4f6f89f6d26c129d4f5bed40552899fcf1f0bf9e50/numpy-1.26.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a", size = 13876746, upload-time = "2024-02-05T23:49:51.983Z" },
+ { url = "https://files.pythonhosted.org/packages/39/fe/39ada9b094f01f5a35486577c848fe274e374bbf8d8f472e1423a0bbd26d/numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2", size = 18078620, upload-time = "2024-02-05T23:50:22.515Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/ef/6ad11d51197aad206a9ad2286dc1aac6a378059e06e8cf22cd08ed4f20dc/numpy-1.26.4-cp310-cp310-win32.whl", hash = "sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07", size = 5972659, upload-time = "2024-02-05T23:50:35.834Z" },
+ { url = "https://files.pythonhosted.org/packages/19/77/538f202862b9183f54108557bfda67e17603fc560c384559e769321c9d92/numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5", size = 15808905, upload-time = "2024-02-05T23:51:03.701Z" },
+ { url = "https://files.pythonhosted.org/packages/11/57/baae43d14fe163fa0e4c47f307b6b2511ab8d7d30177c491960504252053/numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71", size = 20630554, upload-time = "2024-02-05T23:51:50.149Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/2e/151484f49fd03944c4a3ad9c418ed193cfd02724e138ac8a9505d056c582/numpy-1.26.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef", size = 13997127, upload-time = "2024-02-05T23:52:15.314Z" },
+ { url = "https://files.pythonhosted.org/packages/79/ae/7e5b85136806f9dadf4878bf73cf223fe5c2636818ba3ab1c585d0403164/numpy-1.26.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e", size = 14222994, upload-time = "2024-02-05T23:52:47.569Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/d0/edc009c27b406c4f9cbc79274d6e46d634d139075492ad055e3d68445925/numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5", size = 18252005, upload-time = "2024-02-05T23:53:15.637Z" },
+ { url = "https://files.pythonhosted.org/packages/09/bf/2b1aaf8f525f2923ff6cfcf134ae5e750e279ac65ebf386c75a0cf6da06a/numpy-1.26.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a", size = 13885297, upload-time = "2024-02-05T23:53:42.16Z" },
+ { url = "https://files.pythonhosted.org/packages/df/a0/4e0f14d847cfc2a633a1c8621d00724f3206cfeddeb66d35698c4e2cf3d2/numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a", size = 18093567, upload-time = "2024-02-05T23:54:11.696Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/b7/a734c733286e10a7f1a8ad1ae8c90f2d33bf604a96548e0a4a3a6739b468/numpy-1.26.4-cp311-cp311-win32.whl", hash = "sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20", size = 5968812, upload-time = "2024-02-05T23:54:26.453Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/6b/5610004206cf7f8e7ad91c5a85a8c71b2f2f8051a0c0c4d5916b76d6cbb2/numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2", size = 15811913, upload-time = "2024-02-05T23:54:53.933Z" },
+]
+
+[[package]]
+name = "nvidia-cublas"
+version = "13.1.1.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "nvidia-cuda-nvrtc", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a7/a1/0bd24ee8c8d03adac032fd2909426a00c88f8c57961b1277ded97f91119f/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:b7a210458267ac818974c53038fbec2e969d5c99f305ab15c72522fa9f001dd5", size = 542848918, upload-time = "2026-04-08T18:46:22.985Z" },
+ { url = "https://files.pythonhosted.org/packages/3b/cd/154ca20c38269e05eff77c1464e6c1da89f50a6390b565e9d82e06bc11e1/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:37936a16db8fe4ac1f065c2139360608a543a09275cb1a1af612e08cfa065436", size = 423138758, upload-time = "2026-04-08T18:46:58.655Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-cupti"
+version = "13.0.85"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/2a/2a/80353b103fc20ce05ef51e928daed4b6015db4aaa9162ed0997090fe2250/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_aarch64.whl", hash = "sha256:796bd679890ee55fb14a94629b698b6db54bcfd833d391d5e94017dd9d7d3151", size = 10310827, upload-time = "2025-09-04T08:26:42.012Z" },
+ { url = "https://files.pythonhosted.org/packages/33/6d/737d164b4837a9bbd202f5ae3078975f0525a55730fe871d8ed4e3b952b0/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl", hash = "sha256:4eb01c08e859bf924d222250d2e8f8b8ff6d3db4721288cf35d14252a4d933c8", size = 10715597, upload-time = "2025-09-04T08:26:51.312Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-nvrtc"
+version = "13.0.88"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/c3/68/483a78f5e8f31b08fb1bb671559968c0ca3a065ac7acabfc7cee55214fd6/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:ad9b6d2ead2435f11cbb6868809d2adeeee302e9bb94bcf0539c7a40d80e8575", size = 90215200, upload-time = "2025-09-04T08:28:44.204Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/dc/6bb80850e0b7edd6588d560758f17e0550893a1feaf436807d64d2da040f/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d27f20a0ca67a4bb34268a5e951033496c5b74870b868bacd046b1b8e0c3267b", size = 43015449, upload-time = "2025-09-04T08:28:20.239Z" },
+]
+
+[[package]]
+name = "nvidia-cuda-runtime"
+version = "13.0.96"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/87/4f/17d7b9b8e285199c58ce28e31b5c5bbaa4d8271af06a89b6405258245de2/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ef9bcbe90493a2b9d810e43d249adb3d02e98dd30200d86607d8d02687c43f55", size = 2261060, upload-time = "2025-10-09T08:55:15.78Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/24/d1558f3b68b1d26e706813b1d10aa1d785e4698c425af8db8edc3dced472/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7f82250d7782aa23b6cfe765ecc7db554bd3c2870c43f3d1821f1d18aebf0548", size = 2243632, upload-time = "2025-10-09T08:55:36.117Z" },
+]
+
+[[package]]
+name = "nvidia-cudnn-cu13"
+version = "9.20.0.48"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "nvidia-cublas", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/56/c5/83384d846b2fd17c44bd499b36c75a45ed4f095fbbb2252294e89cea5c5c/nvidia_cudnn_cu13-9.20.0.48-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:e31454ae00094b0c55319d9d15b6fa2fc50a9e1c0f5c8c80fb75258234e731e1", size = 444574296, upload-time = "2026-03-09T19:28:27.751Z" },
+ { url = "https://files.pythonhosted.org/packages/6e/5e/edb9c0ae051602c3ccaffe424256463636d639e27d7f302dde9975ef9e7a/nvidia_cudnn_cu13-9.20.0.48-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0c45dd8eeb50b603f07995b1b300c62ffe6a1980482b82b3bcf94a4ca9d49304", size = 366173588, upload-time = "2026-03-09T19:29:34.474Z" },
+]
+
+[[package]]
+name = "nvidia-cufft"
+version = "12.0.0.61"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/2f/7b57e29836ea8714f81e9898409196f47d772d5ddedddf1592eadb8ab743/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6c44f692dce8fd5ffd3e3df134b6cdb9c2f72d99cf40b62c32dde45eea9ddad3", size = 214085489, upload-time = "2025-09-04T08:31:56.044Z" },
+]
+
+[[package]]
+name = "nvidia-cufile"
+version = "1.15.1.6"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/3f/70/4f193de89a48b71714e74602ee14d04e4019ad36a5a9f20c425776e72cd6/nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08a3ecefae5a01c7f5117351c64f17c7c62efa5fffdbe24fc7d298da19cd0b44", size = 1223672, upload-time = "2025-09-04T08:32:22.779Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/73/cc4a14c9813a8a0d509417cf5f4bdaba76e924d58beb9864f5a7baceefbf/nvidia_cufile-1.15.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:bdc0deedc61f548bddf7733bdc216456c2fdb101d020e1ab4b88d232d5e2f6d1", size = 1136992, upload-time = "2025-09-04T08:32:14.119Z" },
+]
+
+[[package]]
+name = "nvidia-curand"
+version = "10.4.0.35"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/1e/72/7c2ae24fb6b63a32e6ae5d241cc65263ea18d08802aaae087d9f013335a2/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:133df5a7509c3e292aaa2b477afd0194f06ce4ea24d714d616ff36439cee349a", size = 61962106, upload-time = "2025-08-04T10:21:41.128Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/9f/be0a41ca4a4917abf5cb9ae0daff1a6060cc5de950aec0396de9f3b52bc5/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:1aee33a5da6e1db083fe2b90082def8915f30f3248d5896bcec36a579d941bfc", size = 59544258, upload-time = "2025-08-04T10:22:03.992Z" },
+]
+
+[[package]]
+name = "nvidia-cusolver"
+version = "12.0.4.66"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "nvidia-cublas", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+ { name = "nvidia-cusparse", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+ { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/67/cba3777620cdacb99102da4042883709c41c709f4b6323c10781a9c3aa34/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0a759da5dea5c0ea10fd307de75cdeb59e7ea4fcb8add0924859b944babf1112", size = 200941980, upload-time = "2025-09-04T08:33:22.767Z" },
+]
+
+[[package]]
+name = "nvidia-cusparse"
+version = "12.6.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "nvidia-nvjitlink", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" },
+ { url = "https://files.pythonhosted.org/packages/fa/18/623c77619c31d62efd55302939756966f3ecc8d724a14dab2b75f1508850/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b3c89c88d01ee0e477cb7f82ef60a11a4bcd57b6b87c33f789350b59759360b", size = 145942937, upload-time = "2025-09-04T08:33:58.029Z" },
+]
+
+[[package]]
+name = "nvidia-cusparselt-cu13"
+version = "0.8.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/46/e1/cdc1797eadf82d3a9a575a19b33fdc871a97edbec42c00b5b5e914f4aff4/nvidia_cusparselt_cu13-0.8.1-py3-none-manylinux2014_aarch64.whl", hash = "sha256:4dca476c50bf4780d46cd0bfbd82e2bc10a08e4fef7950917ce8d7578d22a23f", size = 221051344, upload-time = "2025-09-05T18:49:51.289Z" },
+ { url = "https://files.pythonhosted.org/packages/34/7d/2661f2fb3ac4302f3a246f5fc030213ac60c1fe0bce84f9783dbd831dbb7/nvidia_cusparselt_cu13-0.8.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:786ce87568c303fadb5afcc7102d454cd3040d75f6f8626f5db460d1871f4dd0", size = 170148586, upload-time = "2025-09-05T18:50:50.248Z" },
+]
+
+[[package]]
+name = "nvidia-ml-py"
+version = "13.610.43"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/b5/a8fbc356f768fa5c9cfd646668fd7d34bf55bdd1c6e20754642a64d930d4/nvidia_ml_py-13.610.43.tar.gz", hash = "sha256:65437eb73d68d0c62c931ca4d45038472faff03bd0b8729abba4b899f70d60f2", size = 52109, upload-time = "2026-06-01T18:54:08.829Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/23/45/caa600acfab94560807a20a64b5830d2cd3c3202b7f1328644d70b7d6bd8/nvidia_ml_py-13.610.43-py3-none-any.whl", hash = "sha256:f13c72698edef492f985cc225f14faafe68ae065a2e407f45bdf6f4b9b43fde8", size = 53163, upload-time = "2026-06-01T18:54:07.704Z" },
+]
+
+[[package]]
+name = "nvidia-nccl-cu13"
+version = "2.29.7"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/72/0d/daf50d44177ee0cbc7ff0a0c91eb5ff676c82be42f9a970bc7597f440c3a/nvidia_nccl_cu13-2.29.7-py3-none-manylinux_2_18_aarch64.whl", hash = "sha256:674a12383e3c38a1bcccae7d4f3633b37852230b6047883cb2f4c2d1b36d9bf5", size = 206014712, upload-time = "2026-03-03T05:34:20.843Z" },
+ { url = "https://files.pythonhosted.org/packages/67/f4/58e4e91b6919367c7aafb8e36fce9aad1a3047e536bf7e2fd560927d3a4c/nvidia_nccl_cu13-2.29.7-py3-none-manylinux_2_18_x86_64.whl", hash = "sha256:edd81538446786ec3b73972543e53bb43bcaf0bfc8ef76cb679fcc390ffe136d", size = 205976000, upload-time = "2026-03-03T05:36:24.472Z" },
+]
+
+[[package]]
+name = "nvidia-nvjitlink"
+version = "13.3.33"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f0/ee/580ca6f29dcab0221db8706badca1bbbb084f1975c4d4e83329c3a7e31f0/nvidia_nvjitlink-13.3.33-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:26a6de7fb4c8fdaa7703d3dad720d6d427ddfea5c48a528fd97c11733ad830e5", size = 40742423, upload-time = "2026-05-26T16:54:51.613Z" },
+ { url = "https://files.pythonhosted.org/packages/69/30/45414e35ff2eee7db3da037e5707037ccf9d2b5218ffbdb055ea4d5aa98a/nvidia_nvjitlink-13.3.33-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ce48b37dfeb3cb1eae4cf85adacb47d7a6539ea2272870c9a3628ce275c2037e", size = 39168635, upload-time = "2026-05-26T16:54:13.906Z" },
+]
+
+[[package]]
+name = "nvidia-nvshmem-cu13"
+version = "3.4.5"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/dc/0f/05cc9c720236dcd2db9c1ab97fff629e96821be2e63103569da0c9b72f19/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dc2a197f38e5d0376ad52cd1a2a3617d3cdc150fd5966f4aee9bcebb1d68fe9", size = 60215947, upload-time = "2025-09-06T00:32:20.022Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/35/a9bf80a609e74e3b000fef598933235c908fcefcef9026042b8e6dfde2a9/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:290f0a2ee94c9f3687a02502f3b9299a9f9fe826e6d0287ee18482e78d495b80", size = 60412546, upload-time = "2025-09-06T00:32:41.564Z" },
+]
+
+[[package]]
+name = "nvidia-nvtx"
+version = "13.0.85"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/c2/f3/d86c845465a2723ad7e1e5c36dcd75ddb82898b3f53be47ebd429fb2fa5d/nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4936d1d6780fbe68db454f5e72a42ff64d1fd6397df9f363ae786930fd5c1cd4", size = 148047, upload-time = "2025-09-04T08:29:01.761Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/64/3708a90d1ebe202ffdeb7185f878a3c84d15c2b2c31858da2ce0583e2def/nvidia_nvtx-13.0.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb7780edb6b14107373c835bf8b72e7a178bac7367e23da7acb108f973f157a6", size = 148878, upload-time = "2025-09-04T08:28:53.627Z" },
+]
+
+[[package]]
+name = "opencv-python"
+version = "4.11.0.86"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/17/06/68c27a523103dad5837dc5b87e71285280c4f098c60e4fe8a8db6486ab09/opencv-python-4.11.0.86.tar.gz", hash = "sha256:03d60ccae62304860d232272e4a4fda93c39d595780cb40b161b310244b736a4", size = 95171956, upload-time = "2025-01-16T13:52:24.737Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/05/4d/53b30a2a3ac1f75f65a59eb29cf2ee7207ce64867db47036ad61743d5a23/opencv_python-4.11.0.86-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:432f67c223f1dc2824f5e73cdfcd9db0efc8710647d4e813012195dc9122a52a", size = 37326322, upload-time = "2025-01-16T13:52:25.887Z" },
+ { url = "https://files.pythonhosted.org/packages/3b/84/0a67490741867eacdfa37bc18df96e08a9d579583b419010d7f3da8ff503/opencv_python-4.11.0.86-cp37-abi3-macosx_13_0_x86_64.whl", hash = "sha256:9d05ef13d23fe97f575153558653e2d6e87103995d54e6a35db3f282fe1f9c66", size = 56723197, upload-time = "2025-01-16T13:55:21.222Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/bd/29c126788da65c1fb2b5fb621b7fed0ed5f9122aa22a0868c5e2c15c6d23/opencv_python-4.11.0.86-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b92ae2c8852208817e6776ba1ea0d6b1e0a1b5431e971a2a0ddd2a8cc398202", size = 42230439, upload-time = "2025-01-16T13:51:35.822Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/8b/90eb44a40476fa0e71e05a0283947cfd74a5d36121a11d926ad6f3193cc4/opencv_python-4.11.0.86-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b02611523803495003bd87362db3e1d2a0454a6a63025dc6658a9830570aa0d", size = 62986597, upload-time = "2025-01-16T13:52:08.836Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/d7/1d5941a9dde095468b288d989ff6539dd69cd429dbf1b9e839013d21b6f0/opencv_python-4.11.0.86-cp37-abi3-win32.whl", hash = "sha256:810549cb2a4aedaa84ad9a1c92fbfdfc14090e2749cedf2c1589ad8359aa169b", size = 29384337, upload-time = "2025-01-16T13:52:13.549Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/7d/f1c30a92854540bf789e9cd5dde7ef49bbe63f855b85a2e6b3db8135c591/opencv_python-4.11.0.86-cp37-abi3-win_amd64.whl", hash = "sha256:085ad9b77c18853ea66283e98affefe2de8cc4c1f43eda4c100cf9b2721142ec", size = 39488044, upload-time = "2025-01-16T13:52:21.928Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "2.3.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version < '3.11' and sys_platform == 'win32'",
+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version < '3.11' and sys_platform == 'darwin'",
+]
+dependencies = [
+ { name = "numpy", marker = "python_full_version < '3.11'" },
+ { name = "python-dateutil", marker = "python_full_version < '3.11'" },
+ { name = "pytz", marker = "python_full_version < '3.11'" },
+ { name = "tzdata", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/3d/f7/f425a00df4fcc22b292c6895c6831c0c8ae1d9fac1e024d16f98a9ce8749/pandas-2.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:376c6446ae31770764215a6c937f72d917f214b43560603cd60da6408f183b6c", size = 11555763, upload-time = "2025-09-29T23:16:53.287Z" },
+ { url = "https://files.pythonhosted.org/packages/13/4f/66d99628ff8ce7857aca52fed8f0066ce209f96be2fede6cef9f84e8d04f/pandas-2.3.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e19d192383eab2f4ceb30b412b22ea30690c9e618f78870357ae1d682912015a", size = 10801217, upload-time = "2025-09-29T23:17:04.522Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/03/3fc4a529a7710f890a239cc496fc6d50ad4a0995657dccc1d64695adb9f4/pandas-2.3.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5caf26f64126b6c7aec964f74266f435afef1c1b13da3b0636c7518a1fa3e2b1", size = 12148791, upload-time = "2025-09-29T23:17:18.444Z" },
+ { url = "https://files.pythonhosted.org/packages/40/a8/4dac1f8f8235e5d25b9955d02ff6f29396191d4e665d71122c3722ca83c5/pandas-2.3.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd7478f1463441ae4ca7308a70e90b33470fa593429f9d4c578dd00d1fa78838", size = 12769373, upload-time = "2025-09-29T23:17:35.846Z" },
+ { url = "https://files.pythonhosted.org/packages/df/91/82cc5169b6b25440a7fc0ef3a694582418d875c8e3ebf796a6d6470aa578/pandas-2.3.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4793891684806ae50d1288c9bae9330293ab4e083ccd1c5e383c34549c6e4250", size = 13200444, upload-time = "2025-09-29T23:17:49.341Z" },
+ { url = "https://files.pythonhosted.org/packages/10/ae/89b3283800ab58f7af2952704078555fa60c807fff764395bb57ea0b0dbd/pandas-2.3.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:28083c648d9a99a5dd035ec125d42439c6c1c525098c58af0fc38dd1a7a1b3d4", size = 13858459, upload-time = "2025-09-29T23:18:03.722Z" },
+ { url = "https://files.pythonhosted.org/packages/85/72/530900610650f54a35a19476eca5104f38555afccda1aa11a92ee14cb21d/pandas-2.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:503cf027cf9940d2ceaa1a93cfb5f8c8c7e6e90720a2850378f0b3f3b1e06826", size = 11346086, upload-time = "2025-09-29T23:18:18.505Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790, upload-time = "2025-09-29T23:18:30.065Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831, upload-time = "2025-09-29T23:38:56.071Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267, upload-time = "2025-09-29T23:18:41.627Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281, upload-time = "2025-09-29T23:18:56.834Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453, upload-time = "2025-09-29T23:19:09.247Z" },
+ { url = "https://files.pythonhosted.org/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361, upload-time = "2025-09-29T23:19:25.342Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702, upload-time = "2025-09-29T23:19:38.296Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "3.0.5"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version >= '3.11' and sys_platform == 'win32'",
+ "python_full_version >= '3.11' and sys_platform == 'emscripten'",
+ "python_full_version >= '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version >= '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version >= '3.11' and sys_platform == 'darwin'",
+]
+dependencies = [
+ { name = "numpy", marker = "python_full_version >= '3.11'" },
+ { name = "python-dateutil", marker = "python_full_version >= '3.11'" },
+ { name = "tzdata", marker = "(python_full_version >= '3.11' and sys_platform == 'emscripten') or (python_full_version >= '3.11' and sys_platform == 'win32')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/be/4f/5f3422a2afec5ffc46308b79e53291365a93748b498ac2e58bead0197916/pandas-3.0.5.tar.gz", hash = "sha256:dca3734d6ab7c906e6730f0788b0a1dbb9f2467731f9711f77995c8e9d62d712", size = 4658219, upload-time = "2026-07-22T22:19:28.819Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/48/ef/f1fd7431d635bf20015489bf0bd69c17fff1018de773540f651455a3916b/pandas-3.0.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2946e77e4a53cd248cbde631a12f0e51c8324ce354c3eba4d20147c1ad6f4282", size = 10397178, upload-time = "2026-07-22T22:17:48.274Z" },
+ { url = "https://files.pythonhosted.org/packages/31/b4/0eafac990a431561187694126de01f9b12559549b4d86360c0c4bd870fde/pandas-3.0.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71ecc8fb7ed1a7aa4392316b5309a6347e8e7f832f38fd897846b3a1457a9298", size = 9990736, upload-time = "2026-07-22T22:17:52.388Z" },
+ { url = "https://files.pythonhosted.org/packages/de/21/359880af3ea9b7cb23bea5b51e8e70ef3866c03be09da9a2787e18e330a8/pandas-3.0.5-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b173f5951ff6b8b0ec7675e20dff3c97b7e7a57dfcce387c2d7c5afe87cb7899", size = 10814438, upload-time = "2026-07-22T22:17:54.708Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/50/d6cc4d7e508bbccf5d6027314a8312bc7ac73d0ec7f195f53838daafab40/pandas-3.0.5-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2c0cf1dd9b55a22d105fc46c1b489af3bd42264fcba7c66297bf47a9a1d9c78a", size = 11323634, upload-time = "2026-07-22T22:17:56.858Z" },
+ { url = "https://files.pythonhosted.org/packages/70/2b/d5f0a8c90dd0ae04e64ba53b871afb796ec026b615086d382ddc2ade729b/pandas-3.0.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0fac0010c75e4efb6b99e249c183a8993ce0dc95c240f9b120a5e67c727b7928", size = 11850860, upload-time = "2026-07-22T22:17:59.1Z" },
+ { url = "https://files.pythonhosted.org/packages/5c/30/183aec2e19adf778a98d29b5729a0a68f4cc4ebf9b9c3b70d0297355bcb1/pandas-3.0.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:08d24fe11a17dc33bd6e937dc9c665f9cba08fbdc9f657f405713515febe300d", size = 12411100, upload-time = "2026-07-22T22:18:01.485Z" },
+ { url = "https://files.pythonhosted.org/packages/fa/9a/31f4983f191af51ab2a8f2d0c7b33dff3a84da26533f982fff02c2f9e28b/pandas-3.0.5-cp311-cp311-win_amd64.whl", hash = "sha256:b1261758dfb6cf12c3cff8300e21cefad30e7ec709abb4c24ac7318e6a52462a", size = 9968804, upload-time = "2026-07-22T22:18:03.903Z" },
+ { url = "https://files.pythonhosted.org/packages/49/97/7886c89a39045c69ad82cbceaf3343810480c8ef49a216319ce8183860a6/pandas-3.0.5-cp311-cp311-win_arm64.whl", hash = "sha256:679f4e85b30ddb1515458ab1e788d3e260eae369b1f78da7a3aa4cac8ebf4a2a", size = 9205447, upload-time = "2026-07-22T22:18:06.134Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "12.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/25/c2/669d88644cddb1485bd9534e63e8cf476c8e51cb3c3a1297677023505c0e/pillow-12.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:6c0016e7b354317c4e9e525b937ac8596c38d2d232b419529b9cd7a1cd46e39a", size = 5392418, upload-time = "2026-07-01T11:53:27.808Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/ba/3762f376a2948e3036488d773a146e0ae6ecc2ca03ac20e2615bd0b2ba02/pillow-12.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:bcc33feacfaefce60c12fd500a277533bdc02b10a19f7f6d348763d8140bbba7", size = 4785287, upload-time = "2026-07-01T11:53:29.761Z" },
+ { url = "https://files.pythonhosted.org/packages/07/50/b5d688cc9c52d4482f3d5bcab6ce20bc2a74a85d2343841c907444a3be2c/pillow-12.3.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5594fc43d548a7ed94949d139aa1341b270f1863f11cfd37f5a6c8b778a6b67f", size = 6253754, upload-time = "2026-07-01T11:53:32.298Z" },
+ { url = "https://files.pythonhosted.org/packages/4e/89/36f4cd76cf4baf05c50ababb976249153f18c959171c7f6ba09a6f217260/pillow-12.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f0606c8bf2cdefea14a43530f7657cbbb7ecf1c4222512492ef4a4434a9501ec", size = 6925605, upload-time = "2026-07-01T11:53:34.487Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/c0/4de58cf6633b9e3a6061ef4be6fb91fc3c90b812ece886f531e3c523d777/pillow-12.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:85f998ea1848bc6757289e739cfbdda3a04adfd58b02fc018ce54d754a5ce468", size = 6327788, upload-time = "2026-07-01T11:53:36.433Z" },
+ { url = "https://files.pythonhosted.org/packages/87/3c/14d53682a19550dbbaf3b598f807d5457646c510805a44c7d7891cd1cd1a/pillow-12.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:25b9b82bb22e6e2b3cd07b39c68b7b862001226cb3dff7130d1cb914121b39ed", size = 7036288, upload-time = "2026-07-01T11:53:38.712Z" },
+ { url = "https://files.pythonhosted.org/packages/38/1d/36279e3c77efe034e4cc2b0393ee74ffdb5a62391dacbf9b916154f5f0b8/pillow-12.3.0-cp310-cp310-win32.whl", hash = "sha256:37dc8f7bbb66efe481bb60defacef820c950c24713fb44962ed6aa2a50966de1", size = 6472396, upload-time = "2026-07-01T11:53:40.781Z" },
+ { url = "https://files.pythonhosted.org/packages/48/7c/8fa0039574c476d7c6fa57dd7c32a130436877c6ec1e5ce1cc8ec44878c1/pillow-12.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:300557495eb45ebb8aec96c2da9c4be642fbf7cd937278b4013ba894ea8eb0eb", size = 7226887, upload-time = "2026-07-01T11:53:42.764Z" },
+ { url = "https://files.pythonhosted.org/packages/fa/17/e324be141d173c1c919428066c3259f21c1b8982e564e01a4a81e96dbdcf/pillow-12.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:514435a37670e3e5e08f3945b68718b6ed329bb84367777e16f9f4dfe1e61a0f", size = 2568039, upload-time = "2026-07-01T11:53:45.372Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/c8/0a78b0e02d7ac54bc03e5321c9220da52f0c2ea83b21f7c40e7f3169c502/pillow-12.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:00808c5e14ef63ac5161091d242999076604ff74b883423a11e5d7bbb38bf756", size = 5392415, upload-time = "2026-07-01T11:53:47.162Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/5b/a02d30018abd97ced9f5a6c63d28597694a00d066516b9c1c6de45859fc9/pillow-12.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37d6d0a00072fd2948eb22bce7e1475f34569d90c87c59f7a2ec59541b77f7a6", size = 4785266, upload-time = "2026-07-01T11:53:49.079Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/98/766667a4be768150a202836acd9fad19c06824ca86c4286d3cf6b274964e/pillow-12.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bcb46e2f9feff8d06323983bd83ed00c201fdcab3d74973e7072a889b3979fcd", size = 6263814, upload-time = "2026-07-01T11:53:51.32Z" },
+ { url = "https://files.pythonhosted.org/packages/3b/2d/ede717bc1144f63886c21fd349bb95860b0d1a21149ff16f2bb362b612b6/pillow-12.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23d27a3e0307ec2244cc51e7287b919aa68d097504ebe19df4e76a98a3eea5bd", size = 6934408, upload-time = "2026-07-01T11:53:53.487Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/48/9c58b685e69d49c31af6c8eb9012055fab7e665785165c84796e2c73ce72/pillow-12.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4f883547d4b7f0495ebe7056b0cc2aea76094e7a4abc8e933540f3271df27d9c", size = 6337160, upload-time = "2026-07-01T11:53:55.457Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/fa/dc2a5c0ba6df93f67c31d34b808b7ce440b40cdbf96f0b81cde1d1e6fa93/pillow-12.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:236ff70b9312fb68943c703aa842ca6a758abfa45ac187a5e7c1452e96ef72b5", size = 7045172, upload-time = "2026-07-01T11:53:57.736Z" },
+ { url = "https://files.pythonhosted.org/packages/86/a5/444817a4d4c4c2417df00513086ca196f388d8f9ef40c2e4ccd1ad1af54b/pillow-12.3.0-cp311-cp311-win32.whl", hash = "sha256:10e41f0fbf1eec8cfd234b8fe17a4caac7c9d0db4c204d3c173a8f9f6ef3232b", size = 6472232, upload-time = "2026-07-01T11:53:59.767Z" },
+ { url = "https://files.pythonhosted.org/packages/63/c6/4bad1b18d132a50b27e1365e1ab163616f7a5bb56d330f66f9d1d9d4f9d4/pillow-12.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8e95e1385e4998ae9694eeaa4730ba5457ff61185b3a55e2e7bea0880aef452a", size = 7233653, upload-time = "2026-07-01T11:54:02.066Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/16/00f91ab7760dc842f5aad55217e80fc4a7067a0604535249bc8a2d6d9870/pillow-12.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:ebaea975e03d3141d9d3a507df75c9b3ec90fa9d2ffd07567b3a978d9d790b26", size = 2568195, upload-time = "2026-07-01T11:54:04.622Z" },
+ { url = "https://files.pythonhosted.org/packages/75/18/2e8b40223153ccbc60df07f9e8928dc0c76202aa4e55ae9f53962b6510d6/pillow-12.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b3c777e849237620b022f7f297dd67705f9f5cf1685f09f02e46f93e92725468", size = 5302510, upload-time = "2026-07-01T11:56:25.736Z" },
+ { url = "https://files.pythonhosted.org/packages/46/3e/51fabf59d5ab801ceab709453d3ab6b180083496579549de4c45ced6528a/pillow-12.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b343699e8308bdc51978310e1c959c584e7869cc8c40780058c87da7781a1e94", size = 4736058, upload-time = "2026-07-01T11:56:28.041Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/20/22fe9384b7949e25fb1293bcfc84fb82590ff4ea6b37c95b24d26d793d86/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbd139c8447d25dd750ab79ee274cc5e1fe80fc56340ab10b18a195e1b6eca3e", size = 5237776, upload-time = "2026-07-01T11:56:30.263Z" },
+ { url = "https://files.pythonhosted.org/packages/08/14/f6ba68107680ffa74b39985f3f30884e41318fbc4250caa423c79b4788bb/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7e480451b9fa137494bccd3a7d69adbe8ac65a87d97be61e11f1b1050a5bac3", size = 5860358, upload-time = "2026-07-01T11:56:32.68Z" },
+ { url = "https://files.pythonhosted.org/packages/36/54/0169bc772ec491108b62f644f8ecf1fe5d8ae5ebafde2ee2142210166903/pillow-12.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:04f01d28a6aaff387bf842a13be313df23ba0597a44f1a976c9feb3c6ff4711a", size = 7231786, upload-time = "2026-07-01T11:56:35.046Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "polars"
+version = "1.44.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "polars-runtime-32" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/26/73/258a1fe17bb2744a507199566ed712663144fdd0811b615b59a47dfa38d2/polars-1.44.1.tar.gz", hash = "sha256:ef3c89e9ebbbe8eb343c06873f1945683f8b6f97a1bdf001c60551c6c5e3cda1", size = 765660, upload-time = "2026-08-26T07:09:12.704Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/3a/f1/59154659081930fbde291ea6225607956b500a71b0ce45d88217b7d32da2/polars-1.44.1-py3-none-any.whl", hash = "sha256:1fa62fc1c88fba77a68b28291b5aabdd69e5f38b34e59721a064ae3169b59bb5", size = 865208, upload-time = "2026-08-26T07:07:44.646Z" },
+]
+
+[[package]]
+name = "polars-runtime-32"
+version = "1.44.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/b2/2a76415d047a45df05489f2334c91ff120a274cf655d4ca030c7f54a8743/polars_runtime_32-1.44.1.tar.gz", hash = "sha256:abd10a54ed1caff42228610fcba0f93251f9870bd7cffb0c78bc26f5e0718ce4", size = 3171156, upload-time = "2026-08-26T07:09:14.243Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f1/93/ef9344dcec16757cf21027dc907ef989197e50742cfe4407f2e87edb0a7f/polars_runtime_32-1.44.1-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:1dfccb2b52aa50468a7d28e3e61c8338a13fb5bffc8646e388a649f5bdc6b463", size = 53962370, upload-time = "2026-08-26T07:07:47.21Z" },
+ { url = "https://files.pythonhosted.org/packages/10/da/38b32b7901af33f1fee2172ceaa39e9159825657920064298917392d78fa/polars_runtime_32-1.44.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:0580807dc3eed258f0db70bb65d905dd43f0135392119ec25308033ae24258fb", size = 48620468, upload-time = "2026-08-26T07:07:50.436Z" },
+ { url = "https://files.pythonhosted.org/packages/49/51/185af877d1d2236671493cf72bd3327a6046240eeea69c0696d1af2a5acb/polars_runtime_32-1.44.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0627f9aa82cb869725235e5188f698862fd9ada0c8c1cf65c3dc5a49a4a0ec26", size = 52455947, upload-time = "2026-08-26T07:07:53.776Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/0a/0858f60cb5a6f8f73ec4cdd73eccd9f748d66bfc23304c5c23fa3468094a/polars_runtime_32-1.44.1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eea4283be8e60822d890dbda20588fe59b4172b508bd5ebf3471e531ca9f50d7", size = 58561262, upload-time = "2026-08-26T07:07:57.508Z" },
+ { url = "https://files.pythonhosted.org/packages/73/08/de4774b5612d7c8739f89ac01b601486b4f057b1da35a5b876bf9276fd95/polars_runtime_32-1.44.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:04e2c0f46e7a9906fffb1897f18f23b079b74f83c56b50060bace9e7b9b49b1a", size = 52636064, upload-time = "2026-08-26T07:08:06.337Z" },
+ { url = "https://files.pythonhosted.org/packages/98/ac/769c598dd106e2a6647798da3ed25ddeee67f2d12c04f5da316cb3da6360/polars_runtime_32-1.44.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:0956f0cae632d8fad3a04b4315bf2bb69b56d10c83c79a75c2c4c5a13b9ce5cc", size = 56447612, upload-time = "2026-08-26T07:08:12.36Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/ee/98408296e15388020b6183323fdbe78ccab4f72c20d8e0d7092c062d3ad2/polars_runtime_32-1.44.1-cp310-abi3-win_amd64.whl", hash = "sha256:159334184e6fbb074c9f4692221ea19970a5e2bed2a479f9d7bdb00b7f3eedb9", size = 53702970, upload-time = "2026-08-26T07:08:15.398Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/9d/8b17e075aac73c881a50b6c1f690d20df46db2f3bcabc99f600ecdee1290/polars_runtime_32-1.44.1-cp310-abi3-win_arm64.whl", hash = "sha256:3ba28d638d0513e0b4afbcdab5c0059a85021e5f81d62b5f793e7e23badb2cf7", size = 47281050, upload-time = "2026-08-26T07:08:18.43Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "7.36.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a7/e7/0553e21d25ca4d9f573135775348a372c3ec34a93a71d5f297c3bac38341/protobuf-7.36.0.tar.gz", hash = "sha256:e8e09cb0d794c6687926fa558a8a6e72aa10edb997d5ca61da0765f12a3e00ea", size = 510034, upload-time = "2026-08-20T16:34:01.071Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/8f/ae/58e3ca96cb2e118cc546b677359b3c6659f79a140935c08dec94c7998585/protobuf-7.36.0-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:9103532dffd80c6fab7e50c65a31007680a06eb57537d437bb1b35812c138a37", size = 453256, upload-time = "2026-08-20T16:33:53.945Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/15/5162230af4912697f0fe406f6800f80760945babcff0e2c2fe6c84ef2d5d/protobuf-7.36.0-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:bf94a5917c71058262de683669bc0a797a7669d3de71f0b36d058e3194f47b44", size = 341436, upload-time = "2026-08-20T16:33:55.134Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/09/1670b2bfc9a45e807e520c3e9be36524db9ccc7dc05ea17af7681cabdc61/protobuf-7.36.0-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:3297e60abdff301e5f74393d87f6cc59dacab5f024a89548a6e8de1d26576b16", size = 354440, upload-time = "2026-08-20T16:33:56.077Z" },
+ { url = "https://files.pythonhosted.org/packages/c7/f8/bd5804695ba400e423c33fd4d9f58c28d86633d5ba1945c36ff3967d98cb/protobuf-7.36.0-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:70f5ec8eb0da81a44360c0dc0beac99a0d78071d21956a7076bae8bd2051841b", size = 340439, upload-time = "2026-08-20T16:33:56.992Z" },
+ { url = "https://files.pythonhosted.org/packages/ef/9f/acd02338235a3e7d03168c4303478347b7624fc8189ff4e7f0d2654bbe86/protobuf-7.36.0-cp310-abi3-win32.whl", hash = "sha256:7326fd717bdc419162a735938d89d4032332bcc3408804012b24ff3a37086071", size = 440216, upload-time = "2026-08-20T16:33:57.99Z" },
+ { url = "https://files.pythonhosted.org/packages/0e/4e/12cb93270967a2affff5b3f720694700d4d87712a67afd05c8cb3f6fa52c/protobuf-7.36.0-cp310-abi3-win_amd64.whl", hash = "sha256:1781cc1de61249b750848029bca452c0a8b7e990080316b9bbc2518b2117b488", size = 453731, upload-time = "2026-08-20T16:33:58.951Z" },
+ { url = "https://files.pythonhosted.org/packages/01/c3/629999e78d46c1115c11886d51c6bd68c17ce4a944f1ea3e153a91316a33/protobuf-7.36.0-py3-none-any.whl", hash = "sha256:53374d53fc29a67f7dbbf0ade47d7526a0f0137bf0f9c90e48d8a60790ef748c", size = 177024, upload-time = "2026-08-20T16:34:00.053Z" },
+]
+
+[[package]]
+name = "pso2keras"
+version = "4.0.0"
+source = { editable = "." }
+dependencies = [
+ { name = "numpy" },
+ { name = "scikit-learn", version = "1.7.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+ { name = "scikit-learn", version = "1.9.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+ { name = "tensorboard" },
+ { name = "tomli", marker = "python_full_version < '3.11'" },
+ { name = "torch" },
+ { name = "tqdm" },
+]
+
+[package.optional-dependencies]
+detection = [
+ { name = "ensemble-boxes" },
+ { name = "ultralytics" },
+]
+examples = [
+ { name = "matplotlib", version = "3.10.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+ { name = "matplotlib", version = "3.11.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+ { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+ { name = "pandas", version = "3.0.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+ { name = "torchvision" },
+ { name = "ucimlrepo" },
+]
+
+[package.dev-dependencies]
+dev = [
+ { name = "build" },
+ { name = "pytest" },
+ { name = "twine" },
+]
+
+[package.metadata]
+requires-dist = [
+ { name = "ensemble-boxes", marker = "extra == 'detection'", specifier = "==1.0.9" },
+ { name = "matplotlib", marker = "extra == 'examples'", specifier = ">=3.8,<4" },
+ { name = "numpy", specifier = "<2" },
+ { name = "pandas", marker = "extra == 'examples'" },
+ { name = "scikit-learn" },
+ { name = "tensorboard" },
+ { name = "tomli", marker = "python_full_version < '3.11'", specifier = ">=2" },
+ { name = "torch", specifier = ">=2.13,<3" },
+ { name = "torchvision", marker = "extra == 'examples'", specifier = ">=0.28,<1" },
+ { name = "tqdm" },
+ { name = "ucimlrepo", marker = "extra == 'examples'" },
+ { name = "ultralytics", marker = "extra == 'detection'", specifier = "==8.4.142" },
+]
+provides-extras = ["examples", "detection"]
+
+[package.metadata.requires-dev]
+dev = [
+ { name = "build", specifier = ">=1.3,<2" },
+ { name = "pytest", specifier = ">=9,<10" },
+ { name = "twine", specifier = ">=6,<8" },
+]
+
+[[package]]
+name = "psutil"
+version = "7.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" },
+ { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },
+ { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },
+ { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
+]
+
+[[package]]
+name = "pyparsing"
+version = "3.3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" },
+]
+
+[[package]]
+name = "pyproject-hooks"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", hash = "sha256:1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8", size = 19228, upload-time = "2024-09-29T09:24:13.293Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", hash = "sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913", size = 10216, upload-time = "2024-09-29T09:24:11.978Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "sys_platform == 'win32'" },
+ { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+ { name = "iniconfig" },
+ { name = "packaging" },
+ { name = "pluggy" },
+ { name = "pygments" },
+ { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "pytz"
+version = "2026.3.post1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fb/48/fb042503b6ca6cd271261dc559fd6432f7d8c713153e9ec5c591af4dfc1c/pytz-2026.3.post1.tar.gz", hash = "sha256:2211d3fcf9a797d3405cac96ac7f61d80e6a644f72a3309607282fe8a2010c5d", size = 319745, upload-time = "2026-07-25T15:12:07.385Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0f/7b/39c34ca613b0b198cb866466651b26b045e2009864c5183c979a3b83f383/pytz-2026.3.post1-py2.py3-none-any.whl", hash = "sha256:dd95840dd199baea12d9cc096a1d452caa6596a1c1e4b5f3dbd1541855d5e815", size = 508283, upload-time = "2026-07-25T15:12:05.782Z" },
+]
+
+[[package]]
+name = "pywin32-ctypes"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
+ { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
+ { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
+ { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
+ { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
+ { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
+ { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+ { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+ { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+ { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+ { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+ { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+]
+
+[[package]]
+name = "readme-renderer"
+version = "45.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "docutils" },
+ { name = "nh3" },
+ { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/02/51/d3a6ea424652c60f05600d8c2e01a55c913755e7cdad64afabbd1aa16f44/readme_renderer-45.0.tar.gz", hash = "sha256:030a8fac74904f8fba11ad1bb6964e3f76e896dc7e5e71f16af190c9056696d1", size = 36172, upload-time = "2026-06-09T21:05:17.37Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/97/1b/295bf2fa3e740131778065e5ffa2c481f0e7210182d408e9a2c244ff5b0c/readme_renderer-45.0-py3-none-any.whl", hash = "sha256:3385ed220117104a2bceb4a9dac8c5fdf6d1f96890d7ea2a9c7174fd5c84091f", size = 14134, upload-time = "2026-06-09T21:05:15.85Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.34.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "certifi" },
+ { name = "charset-normalizer" },
+ { name = "idna" },
+ { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" },
+]
+
+[[package]]
+name = "requests-toolbelt"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" },
+]
+
+[[package]]
+name = "rfc3986"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/40/1520d68bfa07ab5a6f065a186815fb6610c86fe957bc065754e47f7b0840/rfc3986-2.0.0.tar.gz", hash = "sha256:97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c", size = 49026, upload-time = "2022-01-10T00:52:30.832Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ff/9a/9afaade874b2fa6c752c36f1548f718b5b83af81ed9b76628329dab81c1b/rfc3986-2.0.0-py2.py3-none-any.whl", hash = "sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd", size = 31326, upload-time = "2022-01-10T00:52:29.594Z" },
+]
+
+[[package]]
+name = "rich"
+version = "15.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "markdown-it-py" },
+ { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" },
+]
+
+[[package]]
+name = "scikit-learn"
+version = "1.7.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version < '3.11' and sys_platform == 'win32'",
+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version < '3.11' and sys_platform == 'darwin'",
+]
+dependencies = [
+ { name = "joblib", marker = "python_full_version < '3.11'" },
+ { name = "numpy", marker = "python_full_version < '3.11'" },
+ { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+ { name = "threadpoolctl", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/c2/a7855e41c9d285dfe86dc50b250978105dce513d6e459ea66a6aeb0e1e0c/scikit_learn-1.7.2.tar.gz", hash = "sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda", size = 7193136, upload-time = "2025-09-09T08:21:29.075Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ba/3e/daed796fd69cce768b8788401cc464ea90b306fb196ae1ffed0b98182859/scikit_learn-1.7.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b33579c10a3081d076ab403df4a4190da4f4432d443521674637677dc91e61f", size = 9336221, upload-time = "2025-09-09T08:20:19.328Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/ce/af9d99533b24c55ff4e18d9b7b4d9919bbc6cd8f22fe7a7be01519a347d5/scikit_learn-1.7.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:36749fb62b3d961b1ce4fedf08fa57a1986cd409eff2d783bca5d4b9b5fce51c", size = 8653834, upload-time = "2025-09-09T08:20:22.073Z" },
+ { url = "https://files.pythonhosted.org/packages/58/0e/8c2a03d518fb6bd0b6b0d4b114c63d5f1db01ff0f9925d8eb10960d01c01/scikit_learn-1.7.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7a58814265dfc52b3295b1900cfb5701589d30a8bb026c7540f1e9d3499d5ec8", size = 9660938, upload-time = "2025-09-09T08:20:24.327Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/75/4311605069b5d220e7cf5adabb38535bd96f0079313cdbb04b291479b22a/scikit_learn-1.7.2-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a847fea807e278f821a0406ca01e387f97653e284ecbd9750e3ee7c90347f18", size = 9477818, upload-time = "2025-09-09T08:20:26.845Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/9b/87961813c34adbca21a6b3f6b2bea344c43b30217a6d24cc437c6147f3e8/scikit_learn-1.7.2-cp310-cp310-win_amd64.whl", hash = "sha256:ca250e6836d10e6f402436d6463d6c0e4d8e0234cfb6a9a47835bd392b852ce5", size = 8886969, upload-time = "2025-09-09T08:20:29.329Z" },
+ { url = "https://files.pythonhosted.org/packages/43/83/564e141eef908a5863a54da8ca342a137f45a0bfb71d1d79704c9894c9d1/scikit_learn-1.7.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7509693451651cd7361d30ce4e86a1347493554f172b1c72a39300fa2aea79e", size = 9331967, upload-time = "2025-09-09T08:20:32.421Z" },
+ { url = "https://files.pythonhosted.org/packages/18/d6/ba863a4171ac9d7314c4d3fc251f015704a2caeee41ced89f321c049ed83/scikit_learn-1.7.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:0486c8f827c2e7b64837c731c8feff72c0bd2b998067a8a9cbc10643c31f0fe1", size = 8648645, upload-time = "2025-09-09T08:20:34.436Z" },
+ { url = "https://files.pythonhosted.org/packages/ef/0e/97dbca66347b8cf0ea8b529e6bb9367e337ba2e8be0ef5c1a545232abfde/scikit_learn-1.7.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:89877e19a80c7b11a2891a27c21c4894fb18e2c2e077815bcade10d34287b20d", size = 9715424, upload-time = "2025-09-09T08:20:36.776Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/32/1f3b22e3207e1d2c883a7e09abb956362e7d1bd2f14458c7de258a26ac15/scikit_learn-1.7.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8da8bf89d4d79aaec192d2bda62f9b56ae4e5b4ef93b6a56b5de4977e375c1f1", size = 9509234, upload-time = "2025-09-09T08:20:38.957Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/71/34ddbd21f1da67c7a768146968b4d0220ee6831e4bcbad3e03dd3eae88b6/scikit_learn-1.7.2-cp311-cp311-win_amd64.whl", hash = "sha256:9b7ed8d58725030568523e937c43e56bc01cadb478fc43c042a9aca1dacb3ba1", size = 8894244, upload-time = "2025-09-09T08:20:41.166Z" },
+]
+
+[[package]]
+name = "scikit-learn"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version >= '3.11' and sys_platform == 'win32'",
+ "python_full_version >= '3.11' and sys_platform == 'emscripten'",
+ "python_full_version >= '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version >= '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version >= '3.11' and sys_platform == 'darwin'",
+]
+dependencies = [
+ { name = "joblib", marker = "python_full_version >= '3.11'" },
+ { name = "narwhals", marker = "python_full_version >= '3.11'" },
+ { name = "numpy", marker = "python_full_version >= '3.11'" },
+ { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+ { name = "threadpoolctl", marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fa/6f/37092bdb25f712817231799fc5674d8e704066a8a70c1d2d40517e18b4ab/scikit_learn-1.9.0.tar.gz", hash = "sha256:8833266989d3a5110178a9fae30783675460724d0e1efb13b14901d2c660c557", size = 7750767, upload-time = "2026-06-02T11:54:32.706Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f5/be/e844fd9586e66540a15b71924d17a6cbc1bb749e81ddd0a796bcdba4c055/scikit_learn-1.9.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9db6f4d34e68c8899e4cab27fdf8eafe6ed21f2ba52ceb25ea250cd237f8e47b", size = 8789686, upload-time = "2026-06-02T11:53:05.439Z" },
+ { url = "https://files.pythonhosted.org/packages/42/e2/ff880f62677a17d035817d543cb0fc8727d01eccbee81c5f7fc733a9d856/scikit_learn-1.9.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:f401448645a3e7bc115aa3c094097865155b34bff1cba8101857d9104e99074c", size = 8256782, upload-time = "2026-06-02T11:53:08.904Z" },
+ { url = "https://files.pythonhosted.org/packages/25/64/eb40435e1a508ab1b4e284ce43ae80f6a162e5be5e38ed5a6fab467a9ea4/scikit_learn-1.9.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fd3a8ef0c758555a3b23c03adaa858af32f7736785ded50ad5991f59c4ed03fa", size = 8992419, upload-time = "2026-06-02T11:53:11.551Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/da/4810a28e473185429e45a57eebcc91fc991b33d889cc0676063e671db03d/scikit_learn-1.9.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f7e254636164090da847715a27f8e5478feb98c40a9e0ee90cbd277de9e5ceb8", size = 9281411, upload-time = "2026-06-02T11:53:15.063Z" },
+ { url = "https://files.pythonhosted.org/packages/3b/67/be3d369f40d8178ba3bd86635d132e08cb5329b023e4669d9426d84bc007/scikit_learn-1.9.0-cp311-cp311-win_amd64.whl", hash = "sha256:5dc1818c77575d149e25fce9ef82dd7b7263ae372f03494158668ad632a69759", size = 8272736, upload-time = "2026-06-02T11:53:18.108Z" },
+ { url = "https://files.pythonhosted.org/packages/37/79/a733f02dc2118da7e77a134b34f39f40201a353311b011d20859d2db3556/scikit_learn-1.9.0-cp311-cp311-win_arm64.whl", hash = "sha256:366652351f092b219c248f1e72821e841960a63d8f358f1dcfd54dc1cbdbbc28", size = 7919564, upload-time = "2026-06-02T11:53:21.2Z" },
+]
+
+[[package]]
+name = "scipy"
+version = "1.15.3"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version < '3.11' and sys_platform == 'win32'",
+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version < '3.11' and sys_platform == 'darwin'",
+]
+dependencies = [
+ { name = "numpy", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/78/2f/4966032c5f8cc7e6a60f1b2e0ad686293b9474b65246b0c642e3ef3badd0/scipy-1.15.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:a345928c86d535060c9c2b25e71e87c39ab2f22fc96e9636bd74d1dbf9de448c", size = 38702770, upload-time = "2025-05-08T16:04:20.849Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/6e/0c3bf90fae0e910c274db43304ebe25a6b391327f3f10b5dcc638c090795/scipy-1.15.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:ad3432cb0f9ed87477a8d97f03b763fd1d57709f1bbde3c9369b1dff5503b253", size = 30094511, upload-time = "2025-05-08T16:04:27.103Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/b1/4deb37252311c1acff7f101f6453f0440794f51b6eacb1aad4459a134081/scipy-1.15.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:aef683a9ae6eb00728a542b796f52a5477b78252edede72b8327a886ab63293f", size = 22368151, upload-time = "2025-05-08T16:04:31.731Z" },
+ { url = "https://files.pythonhosted.org/packages/38/7d/f457626e3cd3c29b3a49ca115a304cebb8cc6f31b04678f03b216899d3c6/scipy-1.15.3-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:1c832e1bd78dea67d5c16f786681b28dd695a8cb1fb90af2e27580d3d0967e92", size = 25121732, upload-time = "2025-05-08T16:04:36.596Z" },
+ { url = "https://files.pythonhosted.org/packages/db/0a/92b1de4a7adc7a15dcf5bddc6e191f6f29ee663b30511ce20467ef9b82e4/scipy-1.15.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:263961f658ce2165bbd7b99fa5135195c3a12d9bef045345016b8b50c315cb82", size = 35547617, upload-time = "2025-05-08T16:04:43.546Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/6d/41991e503e51fc1134502694c5fa7a1671501a17ffa12716a4a9151af3df/scipy-1.15.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2abc762b0811e09a0d3258abee2d98e0c703eee49464ce0069590846f31d40", size = 37662964, upload-time = "2025-05-08T16:04:49.431Z" },
+ { url = "https://files.pythonhosted.org/packages/25/e1/3df8f83cb15f3500478c889be8fb18700813b95e9e087328230b98d547ff/scipy-1.15.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ed7284b21a7a0c8f1b6e5977ac05396c0d008b89e05498c8b7e8f4a1423bba0e", size = 37238749, upload-time = "2025-05-08T16:04:55.215Z" },
+ { url = "https://files.pythonhosted.org/packages/93/3e/b3257cf446f2a3533ed7809757039016b74cd6f38271de91682aa844cfc5/scipy-1.15.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5380741e53df2c566f4d234b100a484b420af85deb39ea35a1cc1be84ff53a5c", size = 40022383, upload-time = "2025-05-08T16:05:01.914Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/84/55bc4881973d3f79b479a5a2e2df61c8c9a04fcb986a213ac9c02cfb659b/scipy-1.15.3-cp310-cp310-win_amd64.whl", hash = "sha256:9d61e97b186a57350f6d6fd72640f9e99d5a4a2b8fbf4b9ee9a841eab327dc13", size = 41259201, upload-time = "2025-05-08T16:05:08.166Z" },
+ { url = "https://files.pythonhosted.org/packages/96/ab/5cc9f80f28f6a7dff646c5756e559823614a42b1939d86dd0ed550470210/scipy-1.15.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:993439ce220d25e3696d1b23b233dd010169b62f6456488567e830654ee37a6b", size = 38714255, upload-time = "2025-05-08T16:05:14.596Z" },
+ { url = "https://files.pythonhosted.org/packages/4a/4a/66ba30abe5ad1a3ad15bfb0b59d22174012e8056ff448cb1644deccbfed2/scipy-1.15.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:34716e281f181a02341ddeaad584205bd2fd3c242063bd3423d61ac259ca7eba", size = 30111035, upload-time = "2025-05-08T16:05:20.152Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/fa/a7e5b95afd80d24313307f03624acc65801846fa75599034f8ceb9e2cbf6/scipy-1.15.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3b0334816afb8b91dab859281b1b9786934392aa3d527cd847e41bb6f45bee65", size = 22384499, upload-time = "2025-05-08T16:05:24.494Z" },
+ { url = "https://files.pythonhosted.org/packages/17/99/f3aaddccf3588bb4aea70ba35328c204cadd89517a1612ecfda5b2dd9d7a/scipy-1.15.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:6db907c7368e3092e24919b5e31c76998b0ce1684d51a90943cb0ed1b4ffd6c1", size = 25152602, upload-time = "2025-05-08T16:05:29.313Z" },
+ { url = "https://files.pythonhosted.org/packages/56/c5/1032cdb565f146109212153339f9cb8b993701e9fe56b1c97699eee12586/scipy-1.15.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:721d6b4ef5dc82ca8968c25b111e307083d7ca9091bc38163fb89243e85e3889", size = 35503415, upload-time = "2025-05-08T16:05:34.699Z" },
+ { url = "https://files.pythonhosted.org/packages/bd/37/89f19c8c05505d0601ed5650156e50eb881ae3918786c8fd7262b4ee66d3/scipy-1.15.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39cb9c62e471b1bb3750066ecc3a3f3052b37751c7c3dfd0fd7e48900ed52982", size = 37652622, upload-time = "2025-05-08T16:05:40.762Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/31/be59513aa9695519b18e1851bb9e487de66f2d31f835201f1b42f5d4d475/scipy-1.15.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:795c46999bae845966368a3c013e0e00947932d68e235702b5c3f6ea799aa8c9", size = 37244796, upload-time = "2025-05-08T16:05:48.119Z" },
+ { url = "https://files.pythonhosted.org/packages/10/c0/4f5f3eeccc235632aab79b27a74a9130c6c35df358129f7ac8b29f562ac7/scipy-1.15.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:18aaacb735ab38b38db42cb01f6b92a2d0d4b6aabefeb07f02849e47f8fb3594", size = 40047684, upload-time = "2025-05-08T16:05:54.22Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/a7/0ddaf514ce8a8714f6ed243a2b391b41dbb65251affe21ee3077ec45ea9a/scipy-1.15.3-cp311-cp311-win_amd64.whl", hash = "sha256:ae48a786a28412d744c62fd7816a4118ef97e5be0bee968ce8f0a2fba7acf3bb", size = 41246504, upload-time = "2025-05-08T16:06:00.437Z" },
+]
+
+[[package]]
+name = "scipy"
+version = "1.17.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+ "python_full_version >= '3.11' and sys_platform == 'win32'",
+ "python_full_version >= '3.11' and sys_platform == 'emscripten'",
+ "python_full_version >= '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
+ "(python_full_version >= '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')",
+ "python_full_version >= '3.11' and sys_platform == 'darwin'",
+]
+dependencies = [
+ { name = "numpy", marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/df/75/b4ce781849931fef6fd529afa6b63711d5a733065722d0c3e2724af9e40a/scipy-1.17.1-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:1f95b894f13729334fb990162e911c9e5dc1ab390c58aa6cbecb389c5b5e28ec", size = 31613675, upload-time = "2026-02-23T00:16:00.13Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/58/bccc2861b305abdd1b8663d6130c0b3d7cc22e8d86663edbc8401bfd40d4/scipy-1.17.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:e18f12c6b0bc5a592ed23d3f7b891f68fd7f8241d69b7883769eb5d5dfb52696", size = 28162057, upload-time = "2026-02-23T00:16:09.456Z" },
+ { url = "https://files.pythonhosted.org/packages/6d/ee/18146b7757ed4976276b9c9819108adbc73c5aad636e5353e20746b73069/scipy-1.17.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a3472cfbca0a54177d0faa68f697d8ba4c80bbdc19908c3465556d9f7efce9ee", size = 20334032, upload-time = "2026-02-23T00:16:17.358Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/e6/cef1cf3557f0c54954198554a10016b6a03b2ec9e22a4e1df734936bd99c/scipy-1.17.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:766e0dc5a616d026a3a1cffa379af959671729083882f50307e18175797b3dfd", size = 22709533, upload-time = "2026-02-23T00:16:25.791Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/60/8804678875fc59362b0fb759ab3ecce1f09c10a735680318ac30da8cd76b/scipy-1.17.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:744b2bf3640d907b79f3fd7874efe432d1cf171ee721243e350f55234b4cec4c", size = 33062057, upload-time = "2026-02-23T00:16:36.931Z" },
+ { url = "https://files.pythonhosted.org/packages/09/7d/af933f0f6e0767995b4e2d705a0665e454d1c19402aa7e895de3951ebb04/scipy-1.17.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43af8d1f3bea642559019edfe64e9b11192a8978efbd1539d7bc2aaa23d92de4", size = 35349300, upload-time = "2026-02-23T00:16:49.108Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/3d/7ccbbdcbb54c8fdc20d3b6930137c782a163fa626f0aef920349873421ba/scipy-1.17.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd96a1898c0a47be4520327e01f874acfd61fb48a9420f8aa9f6483412ffa444", size = 35127333, upload-time = "2026-02-23T00:17:01.293Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/19/f926cb11c42b15ba08e3a71e376d816ac08614f769b4f47e06c3580c836a/scipy-1.17.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4eb6c25dd62ee8d5edf68a8e1c171dd71c292fdae95d8aeb3dd7d7de4c364082", size = 37741314, upload-time = "2026-02-23T00:17:12.576Z" },
+ { url = "https://files.pythonhosted.org/packages/95/da/0d1df507cf574b3f224ccc3d45244c9a1d732c81dcb26b1e8a766ae271a8/scipy-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:d30e57c72013c2a4fe441c2fcb8e77b14e152ad48b5464858e07e2ad9fbfceff", size = 36607512, upload-time = "2026-02-23T00:17:23.424Z" },
+ { url = "https://files.pythonhosted.org/packages/68/7f/bdd79ceaad24b671543ffe0ef61ed8e659440eb683b66f033454dcee90eb/scipy-1.17.1-cp311-cp311-win_arm64.whl", hash = "sha256:9ecb4efb1cd6e8c4afea0daa91a87fbddbce1b99d2895d151596716c0b2e859d", size = 24599248, upload-time = "2026-02-23T00:17:34.561Z" },
+]
+
+[[package]]
+name = "secretstorage"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "cryptography", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+ { name = "jeepney", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32')" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "84.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/44/f5da03a8ef95d369145c5bb53050e7877c9f3d312e128605fd9504829143/setuptools-84.0.0.tar.gz", hash = "sha256:f4695c21257f0d9b537ec2692c941d02ee143b7cc1276941349a546573b2ef73", size = 1168449, upload-time = "2026-08-08T18:27:58.365Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/95/9c/c510029fc6ef33a6275cd2c5d3cecd6613dfd6aa401d57c54f1c18852ccf/setuptools-84.0.0-py3-none-any.whl", hash = "sha256:51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670", size = 818216, upload-time = "2026-08-08T18:27:56.719Z" },
+]
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "sympy"
+version = "1.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "mpmath" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" },
+]
+
+[[package]]
+name = "tensorboard"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "absl-py" },
+ { name = "grpcio" },
+ { name = "markdown" },
+ { name = "numpy" },
+ { name = "packaging" },
+ { name = "pillow" },
+ { name = "protobuf" },
+ { name = "setuptools" },
+ { name = "tensorboard-data-server" },
+ { name = "werkzeug" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/37/4b/cd2eec9642781a8f5b2fb9994e3933a7b259ab18e9d49aeede9b5acf6311/tensorboard-2.21.0-py3-none-any.whl", hash = "sha256:7279316dcb6bd5bc391d623dea841531299cde1887310e8133bc34a996d32255", size = 5516204, upload-time = "2026-06-29T20:48:04.472Z" },
+]
+
+[[package]]
+name = "tensorboard-data-server"
+version = "0.7.2"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7a/13/e503968fefabd4c6b2650af21e110aa8466fe21432cd7c43a84577a89438/tensorboard_data_server-0.7.2-py3-none-any.whl", hash = "sha256:7e0610d205889588983836ec05dc098e80f97b7e7bbff7e994ebb78f578d0ddb", size = 2356, upload-time = "2023-10-23T21:23:32.16Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/85/dabeaf902892922777492e1d253bb7e1264cadce3cea932f7ff599e53fea/tensorboard_data_server-0.7.2-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:9fe5d24221b29625dbc7328b0436ca7fc1c23de4acf4d272f1180856e32f9f60", size = 4823598, upload-time = "2023-10-23T21:23:33.714Z" },
+ { url = "https://files.pythonhosted.org/packages/73/c6/825dab04195756cf8ff2e12698f22513b3db2f64925bdd41671bfb33aaa5/tensorboard_data_server-0.7.2-py3-none-manylinux_2_31_x86_64.whl", hash = "sha256:ef687163c24185ae9754ed5650eb5bc4d84ff257aabdc33f0cc6f74d8ba54530", size = 6590363, upload-time = "2023-10-23T21:23:35.583Z" },
+]
+
+[[package]]
+name = "threadpoolctl"
+version = "3.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", hash = "sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e", size = 21274, upload-time = "2025-03-13T13:49:23.031Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" },
+ { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" },
+ { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" },
+ { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" },
+ { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" },
+ { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" },
+ { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
+]
+
+[[package]]
+name = "torch"
+version = "2.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "cuda-bindings", marker = "sys_platform == 'linux'" },
+ { name = "cuda-toolkit", extra = ["cublas", "cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"], marker = "sys_platform == 'linux'" },
+ { name = "filelock" },
+ { name = "fsspec" },
+ { name = "jinja2" },
+ { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+ { name = "networkx", version = "3.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+ { name = "nvidia-cudnn-cu13", marker = "sys_platform == 'linux'" },
+ { name = "nvidia-cusparselt-cu13", marker = "sys_platform == 'linux'" },
+ { name = "nvidia-nccl-cu13", marker = "sys_platform == 'linux'" },
+ { name = "nvidia-nvshmem-cu13", marker = "sys_platform == 'linux'" },
+ { name = "setuptools" },
+ { name = "sympy" },
+ { name = "triton", marker = "sys_platform == 'linux'" },
+ { name = "typing-extensions" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7f/e7/19894fdb51c7dbaf94f5a79bb0871da0992e8e4241e579cb006da46d2e58/torch-2.13.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:94f0de129916f77b8dc2c7a8eff644cfeddfe59e39c9f55e9f6e17543410281d", size = 111178962, upload-time = "2026-07-08T16:05:49.855Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/5c/b1d5de470c54e339b30a92d96683a71bcebd78f5f2a7fc714cd6dc6bbd68/torch-2.13.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:0ab4b69f3ee03a62a002cfbf77b1ca5e88aceb4ea64cb4388bb28f638ddbb045", size = 427198333, upload-time = "2026-07-08T16:05:36.847Z" },
+ { url = "https://files.pythonhosted.org/packages/50/c0/68a84105e1fcb8970144b388ff3d3e5dc15a3be28c1e247841f7d7247e41/torch-2.13.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:c78b7b4d04461855a764cf01bae9a462bb88bc93defcfa11235cbc8fdf3e12c4", size = 526555154, upload-time = "2026-07-08T16:05:06.507Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/c9/0bb9d097b03cbaf96bb75b15e867347b8e41bfcdfe0539452d17d9e63993/torch-2.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:2bd30b6b730d987fa386ce3898933762c5cb8cc82eb0535211d787cc3ce2dfeb", size = 122015602, upload-time = "2026-07-08T16:05:45.25Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/fe/cba54dc58523434919b66f13a667e36e436deddd77ca519e96553617d4ec/torch-2.13.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:e76f9bcecc52b8ff711239a2f7547d5353df95878ab232f0773c1d95928b92f8", size = 111187938, upload-time = "2026-07-08T16:05:17.065Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/59/1e3160e18e12aa3038390efab3ce02b36a9d4d6a527ecdd8520dca2e68d8/torch-2.13.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:092790c696a760c729fd5722835f50b9d81fd7c8f141571f3f3cf4081a8f664c", size = 427199369, upload-time = "2026-07-08T16:04:51.054Z" },
+ { url = "https://files.pythonhosted.org/packages/01/79/1f2d34ad7034ee1c7ffc1cf8bf0f8213af2a81df6ecdb3997ecec107c09d/torch-2.13.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:60fcdcb2f3876e21146cb4524ef06397d727ca9ad5f020818547e25075fe3cb7", size = 526574961, upload-time = "2026-07-08T16:04:07.075Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/fd/0f2ce40f58aefbdb3392f9acce3c8171940943ae2d661f70558bfa73befb/torch-2.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:a0d8b11f16a48d60e2015d8213aa0390744cbebb98e58b62b3514dddc656e330", size = 122015870, upload-time = "2026-07-08T16:05:27.59Z" },
+]
+
+[[package]]
+name = "torchvision"
+version = "0.28.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "numpy" },
+ { name = "pillow" },
+ { name = "torch" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b4/df/1ba039ad6cfe6e69209c36766b9b6e8c6fe92481c6d4e4ca52296f5f699d/torchvision-0.28.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:2a1ef4b6f4bf5828b48cfad97372c8982db906830884b2868ba5c3df937a7d81", size = 1856019, upload-time = "2026-07-08T16:07:59.283Z" },
+ { url = "https://files.pythonhosted.org/packages/88/ea/5c70ecf86f8e95174a85061cea78683a7bb7f422f09c3f3d4f30b7600fa9/torchvision-0.28.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:546fd85345cf8652f6cd099d4f9884b0ca5c2f3fae78689a21dd2f35ea6b622f", size = 7838211, upload-time = "2026-07-08T16:07:27.023Z" },
+ { url = "https://files.pythonhosted.org/packages/46/22/2f7ff1997d793e45d85fafa8374ee25348b7dae9ac521ba8751d7e1c75d5/torchvision-0.28.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:6dfb0f45e2b4ceb4e76f158c3fbb5f44387099f3c466e3423a09ab665a194aba", size = 7669419, upload-time = "2026-07-08T16:07:41.648Z" },
+ { url = "https://files.pythonhosted.org/packages/42/d0/2b3c30834ff23acd3854d0ff59bc580711f4b36d725de40105a852ed3719/torchvision-0.28.0-cp310-cp310-win_amd64.whl", hash = "sha256:7fad44dc9582570c7d92c4487d36ac46998f40cc39b438e8b8f5111a935ce4e8", size = 3500355, upload-time = "2026-07-08T16:07:56.865Z" },
+ { url = "https://files.pythonhosted.org/packages/7a/b2/1e010052079e4c577007b789db336ea7075f1a426e84d17121fbc3745516/torchvision-0.28.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:83fe6c020866a85acd7d97deccc45ff11d66daf42916d04396a4309c66c0ccb8", size = 1856017, upload-time = "2026-07-08T16:07:55.533Z" },
+ { url = "https://files.pythonhosted.org/packages/27/be/1b9c5de9c655ca2df4a74100fa671a7b848532ff787e077ccde14a7dea2a/torchvision-0.28.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:5a38bc6da3d72621be003400b66f66a2b4c6d644fde05f680c2cb7ca8cf8dd6c", size = 7841822, upload-time = "2026-07-08T16:07:49.207Z" },
+ { url = "https://files.pythonhosted.org/packages/0b/9b/f1e68e861d4462e3e195a642c2b448e7b7d3fad5f209487162b9a2133d9b/torchvision-0.28.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:7e80f543b22503d9415e126db5f0ff3917036925e38560ee6b9ae38c571a4002", size = 7670718, upload-time = "2026-07-08T16:07:46.525Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/de/1494610ff54cbb154beb55033cc2cd50f3de04dac132fa2dd00e4f2b2556/torchvision-0.28.0-cp311-cp311-win_amd64.whl", hash = "sha256:9a45ea67235d965ef52187130d20002a4de20c54ea3d927a24286961d268dc37", size = 3814319, upload-time = "2026-07-08T16:07:37.153Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.70.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/21/3b/6c24bec5be5e743ffd99576daa5cc077722fc7d5bbc00bd133fa0c698dc6/tqdm-4.70.0.tar.gz", hash = "sha256:55b0b0dbd97462d06ebee91e4dac24ed4d4702be82b24f07e6c1d27e08cea220", size = 795438, upload-time = "2026-07-27T11:33:15.271Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f9/1c/01bfd571a64e7f270e6bab5e33777debe0edc56759233ce84f27dec92d14/tqdm-4.70.0-py3-none-any.whl", hash = "sha256:7f585706bfddbdebf89daac705b2dfcc16890130727d3197ca62c732b4310953", size = 80184, upload-time = "2026-07-27T11:33:13.167Z" },
+]
+
+[[package]]
+name = "triton"
+version = "3.7.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ec/ea/629cc37436ca5df93ce98956d09cd2ca1498bfee8ef4972d2fe48b9f958c/triton-3.7.1-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3daf64305d6cea88d3334c65ebc9bcd0c64c9564a977084366aa768d57cbcf64", size = 184551013, upload-time = "2026-06-17T20:03:37.551Z" },
+ { url = "https://files.pythonhosted.org/packages/15/76/c79c34311625227a288df3e483fc5cdf3d596624cbd4b4758c4cbdc14af3/triton-3.7.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee89fbf782ec2ad50391dd1cf26cbea4f4467154c37f4773026da8fc31c0f58e", size = 197596267, upload-time = "2026-06-17T19:53:06.898Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/f9/19d842d06a08559534fa1eaab6ca551b1bcf40f06620bddec1babaa2772d/triton-3.7.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4a0e1cd4c4a76370ed74a8432a53cea28716827d19e40ffc732233e35ceb3f6", size = 184664887, upload-time = "2026-06-17T20:03:42.913Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/5e/fce69606f7f240297f163e25539906732b199530d486ce67ae319877e821/triton-3.7.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6744957e9fd610a29680ec2346057d0c86948ed3812468670719f391e94b44a5", size = 197701306, upload-time = "2026-06-17T19:53:13.673Z" },
+]
+
+[[package]]
+name = "twine"
+version = "7.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "id" },
+ { name = "keyring", marker = "platform_machine != 'ppc64le' and platform_machine != 's390x'" },
+ { name = "packaging" },
+ { name = "readme-renderer" },
+ { name = "requests" },
+ { name = "requests-toolbelt" },
+ { name = "rfc3986" },
+ { name = "rich" },
+ { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/92/3c/58f808a359700f39a967dffede33efeac809262c03303fa3eec6afff8f49/twine-7.0.0.tar.gz", hash = "sha256:85cdb29c518efef867360ae4acd4b0dfd61c8654a22fca08e6f8539f05022177", size = 215032, upload-time = "2026-07-27T15:59:00.825Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/96/08/ddcdc06225eaad6de0e48e1002b06d919dbde20582d0662c7af51308e5d6/twine-7.0.0-py3-none-any.whl", hash = "sha256:b854164df26db268af05f49aa5c0344b10e27a494343ff05b1e0bad3b135f5a7", size = 43204, upload-time = "2026-07-27T15:58:59.26Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
+]
+
+[[package]]
+name = "tzdata"
+version = "2026.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/92/ff/5a28bdfd8c3ebec42564ac7d0e54ca3db65044a9314a97f9564fa7a1e926/tzdata-2026.3.tar.gz", hash = "sha256:4a1518b8993086a7982523e071643f3c0e5f213e75b21318e78bcabfff9d1415", size = 198674, upload-time = "2026-07-10T08:50:37.887Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e5/6d/b53b99a9f2766d095985947a5782f1702cabb129a34f7a802d7197af832f/tzdata-2026.3-py2.py3-none-any.whl", hash = "sha256:dc096730c87af6cab1b171c9d532be840741ff5d459015e7f6947bd7d7e54931", size = 348168, upload-time = "2026-07-10T08:50:36.46Z" },
+]
+
+[[package]]
+name = "ucimlrepo"
+version = "0.0.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "certifi" },
+ { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+ { name = "pandas", version = "3.0.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/87/7c/f5a400cc99a5365d153609ebf803084f78b4638b0f7925aa31d9abb62b8e/ucimlrepo-0.0.7.tar.gz", hash = "sha256:4cff3f9e814367dd60956da999ace473197237b9fce4c07e9a689e77b4ffb59a", size = 9369, upload-time = "2024-05-21T06:06:41.465Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/3b/07/1252560194df2b4fad1cb3c46081b948331c63eb1bb0b97620d508d12a53/ucimlrepo-0.0.7-py3-none-any.whl", hash = "sha256:0a5ce7e21d7ec850a0da4427c47f9dd96fcc6532f1c7e95dcec63eeb40f08026", size = 8041, upload-time = "2024-05-21T06:06:39.826Z" },
+]
+
+[[package]]
+name = "ultralytics"
+version = "8.4.142"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "cloudpickle" },
+ { name = "filelock" },
+ { name = "matplotlib", version = "3.10.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+ { name = "matplotlib", version = "3.11.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
+ { name = "numpy" },
+ { name = "nvidia-ml-py" },
+ { name = "opencv-python" },
+ { name = "pillow" },
+ { name = "polars" },
+ { name = "psutil" },
+ { name = "pyyaml" },
+ { name = "requests" },
+ { name = "torch" },
+ { name = "torchvision" },
+ { name = "ultralytics-platform", marker = "python_full_version >= '3.11'" },
+ { name = "ultralytics-thop" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/85/f3/f18125b18a3814046ca39bd537f3aaec70dcb1171532fd5569b6b5fecb6e/ultralytics-8.4.142.tar.gz", hash = "sha256:d815e4d41a057213a0ce53a87dc307b99e0c993c45116d6435bd2e6126b26f76", size = 1226009, upload-time = "2026-09-05T23:28:22.864Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7a/60/b19191be12ece136b53a3411f5441e9cc417ac02cd911cd484f680205dcf/ultralytics-8.4.142-py3-none-any.whl", hash = "sha256:a810bf24f028d98c3f49d79eb0ff84a0cf08e5326e7f557045170ffe5ce356b5", size = 1443041, upload-time = "2026-09-05T23:28:18.249Z" },
+]
+
+[[package]]
+name = "ultralytics-platform"
+version = "0.1.21"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "httpx", marker = "python_full_version >= '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/65/61/881fdc4bbe5fe7277278d814531aff51dec9431388c6fd7b8a753b1b5def/ultralytics_platform-0.1.21.tar.gz", hash = "sha256:d408a2274800b51cca543aef21e96f6405c022df3d6c81dc4559375980c4eed1", size = 54878, upload-time = "2026-09-01T00:46:18.25Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/fb/a8/11a454efdf6a326d735cef2e01e0f86e4b9732d583b5e5c95d1ea057b934/ultralytics_platform-0.1.21-py3-none-any.whl", hash = "sha256:f1c8a0ccfef543c0cc573b264e0bdd29605d3b67a21aee56ffe02ea611099c8d", size = 66181, upload-time = "2026-09-01T00:46:16.614Z" },
+]
+
+[[package]]
+name = "ultralytics-thop"
+version = "2.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "numpy" },
+ { name = "torch" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/45/20/d6b6aaa8ecf7dbdeaf0c05f73bdcd04cf8ce468d936bc48dbcd368e75baf/ultralytics_thop-2.1.6.tar.gz", hash = "sha256:0ec2df8ebd3db35795e1f80cdc8bce6734446dbe989bca1b0c89396353f0f08c", size = 36364, upload-time = "2026-07-30T22:31:28.143Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/53/98/f1fa3d40d548c8a2a3eec33b7f856063bb6c7d51e16d5198b1f390b2c79d/ultralytics_thop-2.1.6-py3-none-any.whl", hash = "sha256:23f7b8ad124fa3432c1a7de9279102c4fdda699216032a7dff49f87ec3d1a3af", size = 30479, upload-time = "2026-07-30T22:31:26.874Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+]
+
+[[package]]
+name = "werkzeug"
+version = "3.1.8"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/dd/b2/381be8cfdee792dd117872481b6e378f85c957dd7c5bca38897b08f765fd/werkzeug-3.1.8.tar.gz", hash = "sha256:9bad61a4268dac112f1c5cd4630a56ede601b6ed420300677a869083d70a4c44", size = 875852, upload-time = "2026-04-02T18:49:14.268Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/93/8c/2e650f2afeb7ee576912636c23ddb621c91ac6a98e66dc8d29c3c69446e1/werkzeug-3.1.8-py3-none-any.whl", hash = "sha256:63a77fb8892bf28ebc3178683445222aa500e48ebad5ec77b0ad80f8726b1f50", size = 226459, upload-time = "2026-04-02T18:49:12.72Z" },
+]
+
+[[package]]
+name = "zipp"
+version = "4.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b9/d8/eab98a517c14134c0b2eb4e2387bc5f457334293ec5d2dd3857ec2966802/zipp-4.1.0.tar.gz", hash = "sha256:4cb57381f544315db7688e976e922a2b18cdb513d21cc194eb42232ba2a3e602", size = 26214, upload-time = "2026-05-18T20:08:57.967Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/3a/13/547360d81e6d88d58492968ffda9f9542854f11310ee556fef14260cc886/zipp-4.1.0-py3-none-any.whl", hash = "sha256:25ad4e16390cd314347dd8f1de67a2ac538ae658ed4ab9db16029c07c188e97f", size = 10238, upload-time = "2026-05-18T20:08:57.045Z" },
+]