diff options
| author | YurenHao0426 <blackhao0426@gmail.com> | 2026-06-13 12:35:36 -0500 |
|---|---|---|
| committer | YurenHao0426 <blackhao0426@gmail.com> | 2026-06-13 12:35:36 -0500 |
| commit | 66e0d8b9fd4d0f7a2231d689c055e26fdf1cf04a (patch) | |
| tree | c29cba61124018755a19b02c9d33e3ad5f2e05cc /srm | |
Curated export for clone-and-run Maze training (2x A6000) + diagnostics.
trm/hrm pretrain.py carry trajectory-augmentation code (backward-compatible).
Heavy artifacts (checkpoints/wandb/npz) gitignored; see PROVENANCE.md.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Diffstat (limited to 'srm')
35 files changed, 53850 insertions, 0 deletions
diff --git a/srm/.gitignore b/srm/.gitignore new file mode 100644 index 0000000..e94e174 --- /dev/null +++ b/srm/.gitignore @@ -0,0 +1,171 @@ +# WandB +/wandb/ +# checkpoints +/checkpoints/ +/ckpts/ +# cache +/cache/ +/.codex/ +# data +/data/ + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/
\ No newline at end of file diff --git a/srm/.gitmodules b/srm/.gitmodules new file mode 100644 index 0000000..2247fc8 --- /dev/null +++ b/srm/.gitmodules @@ -0,0 +1,9 @@ +[submodule "dataset/raw-data/ConceptARC"] + path = dataset/raw-data/ConceptARC + url = git@github.com:victorvikram/ConceptARC.git +[submodule "dataset/raw-data/ARC-AGI"] + path = dataset/raw-data/ARC-AGI + url = git@github.com:fchollet/ARC-AGI.git +[submodule "dataset/raw-data/ARC-AGI-2"] + path = dataset/raw-data/ARC-AGI-2 + url = git@github.com:arcprize/ARC-AGI-2.git diff --git a/srm/.vscode/launch.json b/srm/.vscode/launch.json new file mode 100644 index 0000000..d49f941 --- /dev/null +++ b/srm/.vscode/launch.json @@ -0,0 +1,26 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "name": "Python Debugger: Current File", + "type": "debugpy", + "request": "launch", + "program": "${file}", + "console": "integratedTerminal" + }, + { + "name": "Debug: Single GPU", + "type": "debugpy", + "request": "launch", + "program": "pretrain.py", + "args": [], + "env": { + "OMP_NUM_THREADS": "1", + "DISABLE_COMPILE": "true" + } + } + ] +}
\ No newline at end of file diff --git a/srm/.vscode/settings.json b/srm/.vscode/settings.json new file mode 100644 index 0000000..8aef7b1 --- /dev/null +++ b/srm/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "python.analysis.typeCheckingMode": "standard" +}
\ No newline at end of file diff --git a/srm/LICENSE b/srm/LICENSE new file mode 100644 index 0000000..7a4a3ea --- /dev/null +++ b/srm/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License.
\ No newline at end of file diff --git a/srm/README.md b/srm/README.md new file mode 100644 index 0000000..83c88d0 --- /dev/null +++ b/srm/README.md @@ -0,0 +1,196 @@ +# Hierarchical Reasoning Model + + + +Reasoning, the process of devising and executing complex goal-oriented action sequences, remains a critical challenge in AI. +Current large language models (LLMs) primarily employ Chain-of-Thought (CoT) techniques, which suffer from brittle task decomposition, extensive data requirements, and high latency. Inspired by the hierarchical and multi-timescale processing in the human brain, we propose the Hierarchical Reasoning Model (HRM), a novel recurrent architecture that attains significant computational depth while maintaining both training stability and efficiency. +HRM executes sequential reasoning tasks in a single forward pass without explicit supervision of the intermediate process, through two interdependent recurrent modules: a high-level module responsible for slow, abstract planning, and a low-level module handling rapid, detailed computations. With only 27 million parameters, HRM achieves exceptional performance on complex reasoning tasks using only 1000 training samples. The model operates without pre-training or CoT data, yet achieves nearly perfect performance on challenging tasks including complex Sudoku puzzles and optimal path finding in large mazes. +Furthermore, HRM outperforms much larger models with significantly longer context windows on the Abstraction and Reasoning Corpus (ARC), a key benchmark for measuring artificial general intelligence capabilities. +These results underscore HRM’s potential as a transformative advancement toward universal computation and general-purpose reasoning systems. + +Read Our Paper: [https://arxiv.org/abs/2506.21734](https://arxiv.org/abs/2506.21734) + +**Join Our Discord Community: [https://discord.gg/sapient](https://discord.gg/sapient)** + + +## Quick Start Guide 🚀 + +### Prerequisites ⚙️ + +Ensure PyTorch and CUDA are installed. The repo needs CUDA extensions to be built. If not present, run the following commands: + +```bash +# Install CUDA 12.6 +CUDA_URL=https://developer.download.nvidia.com/compute/cuda/12.6.3/local_installers/cuda_12.6.3_560.35.05_linux.run + +wget -q --show-progress --progress=bar:force:noscroll -O cuda_installer.run $CUDA_URL +sudo sh cuda_installer.run --silent --toolkit --override + +export CUDA_HOME=/usr/local/cuda-12.6 + +# Install PyTorch with CUDA 12.6 +PYTORCH_INDEX_URL=https://download.pytorch.org/whl/cu126 + +pip3 install torch torchvision torchaudio --index-url $PYTORCH_INDEX_URL + +# Additional packages for building extensions +pip3 install packaging ninja wheel setuptools setuptools-scm +``` + +Then install FlashAttention. For Hopper GPUs, install FlashAttention 3 + +```bash +git clone git@github.com:Dao-AILab/flash-attention.git +cd flash-attention/hopper +python setup.py install +``` + +For Ampere or earlier GPUs, install FlashAttention 2 + +```bash +pip3 install flash-attn +``` + +## Install Python Dependencies 🐍 + +```bash +pip install -r requirements.txt +``` + +## W&B Integration 📈 + +This project uses [Weights & Biases](https://wandb.ai/) for experiment tracking and metric visualization. Ensure you're logged in: + +```bash +wandb login +``` + +## Run Experiments + +### Quick Demo: Sudoku Solver 💻🗲 + +Train a master-level Sudoku AI capable of solving extremely difficult puzzles on a modern laptop GPU. 🧩 + +```bash +# Download and build Sudoku dataset +python dataset/build_sudoku_dataset.py --output-dir data/sudoku-extreme-1k-aug-1000 --subsample-size 1000 --num-aug 1000 + +# Start training (single GPU, smaller batch size) +OMP_NUM_THREADS=8 python pretrain.py data_path=data/sudoku-extreme-1k-aug-1000 epochs=20000 eval_interval=2000 global_batch_size=384 lr=7e-5 puzzle_emb_lr=7e-5 weight_decay=1.0 puzzle_emb_weight_decay=1.0 +``` + +Runtime: ~10 hours on a RTX 4070 laptop GPU + +## Trained Checkpoints 🚧 + + - [ARC-AGI-2](https://huggingface.co/sapientinc/HRM-checkpoint-ARC-2) + - [Sudoku 9x9 Extreme (1000 examples)](https://huggingface.co/sapientinc/HRM-checkpoint-sudoku-extreme) + - [Maze 30x30 Hard (1000 examples)](https://huggingface.co/sapientinc/HRM-checkpoint-maze-30x30-hard) + +To use the checkpoints, see Evaluation section below. + +## Full-scale Experiments 🔵 + +Experiments below assume an 8-GPU setup. + +### Dataset Preparation + +```bash +# Initialize submodules +git submodule update --init --recursive + +# ARC-1 +python dataset/build_arc_dataset.py # ARC offical + ConceptARC, 960 examples +# ARC-2 +python dataset/build_arc_dataset.py --dataset-dirs dataset/raw-data/ARC-AGI-2/data --output-dir data/arc-2-aug-1000 # ARC-2 official, 1120 examples + +# Sudoku-Extreme +python dataset/build_sudoku_dataset.py # Full version +python dataset/build_sudoku_dataset.py --output-dir data/sudoku-extreme-1k-aug-1000 --subsample-size 1000 --num-aug 1000 # 1000 examples + +# Maze +python dataset/build_maze_dataset.py # 1000 examples +``` + +### Dataset Visualization + +Explore the puzzles visually: + +* Open `puzzle_visualizer.html` in your browser. +* Upload the generated dataset folder located in `data/...`. + +## Launch experiments + +### Small-sample (1K) + +ARC-1: + +```bash +OMP_NUM_THREADS=8 torchrun --nproc-per-node 8 pretrain.py +``` + +*Runtime:* ~24 hours + +ARC-2: + +```bash +OMP_NUM_THREADS=8 torchrun --nproc-per-node 8 pretrain.py data_path=data/arc-2-aug-1000 +``` + +*Runtime:* ~24 hours (checkpoint after 8 hours is often sufficient) + +Sudoku Extreme (1k): + +```bash +OMP_NUM_THREADS=8 torchrun --nproc-per-node 8 pretrain.py data_path=data/sudoku-extreme-1k-aug-1000 epochs=20000 eval_interval=2000 lr=1e-4 puzzle_emb_lr=1e-4 weight_decay=1.0 puzzle_emb_weight_decay=1.0 +``` + +*Runtime:* ~10 minutes + +Maze 30x30 Hard (1k): + +```bash +OMP_NUM_THREADS=8 torchrun --nproc-per-node 8 pretrain.py data_path=data/maze-30x30-hard-1k epochs=20000 eval_interval=2000 lr=1e-4 puzzle_emb_lr=1e-4 weight_decay=1.0 puzzle_emb_weight_decay=1.0 +``` + +*Runtime:* ~1 hour + +### Full Sudoku-Hard + +```bash +OMP_NUM_THREADS=8 torchrun --nproc-per-node 8 pretrain.py data_path=data/sudoku-hard-full epochs=100 eval_interval=10 lr_min_ratio=0.1 global_batch_size=2304 lr=3e-4 puzzle_emb_lr=3e-4 weight_decay=0.1 puzzle_emb_weight_decay=0.1 arch.loss.loss_type=softmax_cross_entropy arch.L_cycles=8 arch.halt_max_steps=8 arch.pos_encodings=learned +``` + +*Runtime:* ~2 hours + +## Evaluation + +Evaluate your trained models: + +* Check `eval/exact_accuracy` in W&B. +* For ARC-AGI, follow these additional steps: + +```bash +OMP_NUM_THREADS=8 torchrun --nproc-per-node 8 evaluate.py checkpoint=<CHECKPOINT_PATH> +``` + +* Then use the provided `arc_eval.ipynb` notebook to finalize and inspect your results. + +## Notes + + - Small-sample learning typically exhibits accuracy variance of around ±2 points. + - For Sudoku-Extreme (1,000-example dataset), late-stage overfitting may cause numerical instability during training and Q-learning. It is advisable to use early stopping once the training accuracy approaches 100%. + +## Citation 📜 + +```bibtex +@misc{wang2025hierarchicalreasoningmodel, + title={Hierarchical Reasoning Model}, + author={Guan Wang and Jin Li and Yuhao Sun and Xing Chen and Changling Liu and Yue Wu and Meng Lu and Sen Song and Yasin Abbasi Yadkori}, + year={2025}, + eprint={2506.21734}, + archivePrefix={arXiv}, + primaryClass={cs.AI}, + url={https://arxiv.org/abs/2506.21734}, +} +``` diff --git a/srm/arc_eval.ipynb b/srm/arc_eval.ipynb new file mode 100644 index 0000000..b2786b8 --- /dev/null +++ b/srm/arc_eval.ipynb @@ -0,0 +1,252 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "from glob import glob\n", + "import hashlib\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as mcolors\n", + "\n", + "import torch\n", + "import torch.nn.functional as F\n", + "import numpy as np\n", + "from numba import njit\n", + "\n", + "from dataset.common import inverse_dihedral_transform\n", + "\n", + "\n", + "DATASET_PATH = \"data/arc-aug-1000\" # ARC-1\n", + "# DATASET_PATH = \"data/arc-2-aug-1000\" # ARC-2\n", + "\n", + "CHECKPOINT_PATH = \"checkpoints/Arc-aug-1000 ACT-torch/HierarchicalReasoningModel_ACTV1 amphibian-turaco/step_414456\"\n", + "\n", + "\n", + "PAD_PUZZLE_IDENTIFIER = 0\n", + "\n", + "# Visualization\n", + "ARC_COLOR_MAP = mcolors.ListedColormap([\n", + " \"#000000\", # symbol_0: black\n", + " \"#0074D9\", # symbol_1: blue\n", + " \"#FF4136\", # symbol_2: red\n", + " \"#2ECC40\", # symbol_3: green\n", + " \"#FFDC00\", # symbol_4: yellow\n", + " \"#AAAAAA\", # symbol_5: grey\n", + " \"#F012BE\", # symbol_6: fuschia\n", + " \"#FF851B\", # symbol_7: orange\n", + " \"#7FDBFF\", # symbol_8: teal\n", + " \"#870C25\" # symbol_9: brown\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def load_identifiers_and_preds(dataset_path: str, checkpoint_path: str):\n", + " # Load puzzle identifiers\n", + " with open(os.path.join(dataset_path, \"identifiers.json\"), \"r\") as f:\n", + " identifier_map = json.load(f)\n", + " \n", + " # Load preds\n", + " all_preds = {}\n", + " for filename in glob(f\"{checkpoint_path}_all_preds.*\"):\n", + " preds = torch.load(filename)\n", + " for k, v in preds.items():\n", + " all_preds.setdefault(k, [])\n", + " all_preds[k].append(v)\n", + " \n", + " del preds\n", + "\n", + " all_preds = {k: torch.cat(v, dim=0) for k, v in all_preds.items()}\n", + " \n", + " # Remove paddings\n", + " mask = all_preds[\"puzzle_identifiers\"] != PAD_PUZZLE_IDENTIFIER\n", + " all_preds = {k: v[mask] for k, v in all_preds.items()}\n", + "\n", + " return identifier_map, all_preds\n", + "\n", + "\n", + "def inverse_aug(name: str, grid: np.ndarray):\n", + " if \"_\" not in name:\n", + " return grid\n", + "\n", + " trans_id, perm = name.split(\"_\")[-2:]\n", + " trans_id = int(trans_id[1:]) # Remove \"t\" letter\n", + " inv_perm = np.argsort(list(perm))\n", + " \n", + " return inv_perm[inverse_dihedral_transform(grid, trans_id)]\n", + "\n", + "\n", + "def grid_hash(grid: np.ndarray):\n", + " return hash((grid.tobytes(), grid.shape))\n", + "\n", + "\n", + "@njit\n", + "def crop(grid: np.ndarray):\n", + " # Find maximum-sized rectangle without any EOS token inside.\n", + " grid = grid.reshape(30, 30)\n", + "\n", + " max_area = 0\n", + " max_size = (0, 0)\n", + " nr, nc = grid.shape\n", + " \n", + " num_c = nc\n", + " for num_r in range(1, nr + 1):\n", + " # Scan for maximum c\n", + " for c in range(1, num_c + 1):\n", + " x = grid[num_r - 1, c - 1]\n", + " if (x < 2) | (x > 11):\n", + " num_c = c - 1\n", + " break\n", + " \n", + " area = num_r * num_c\n", + " if area > max_area:\n", + " max_area = area\n", + " max_size = (num_r, num_c)\n", + "\n", + " return grid[:max_size[0], :max_size[1]] - 2\n", + "\n", + "\n", + "def test(visualize, Ks=[1, 2, 10, 100, 1000]):\n", + " identifier_map, all_preds = load_identifiers_and_preds(DATASET_PATH, CHECKPOINT_PATH)\n", + " \n", + " global_hmap = {}\n", + " \n", + " # Get puzzles and corresponding answers\n", + " puzzle_labels = {}\n", + " for identifier, input, label in zip(all_preds[\"puzzle_identifiers\"], all_preds[\"inputs\"], all_preds[\"labels\"]):\n", + " name = identifier_map[identifier]\n", + " if \"_\" not in name: # Not-augmented\n", + " puzzle_labels.setdefault(name, {})\n", + " \n", + " input = crop(input.numpy())\n", + " label = crop(label.numpy())\n", + "\n", + " input_hash = grid_hash(input)\n", + " label_hash = grid_hash(label)\n", + "\n", + " global_hmap[input_hash] = input\n", + " global_hmap[label_hash] = label\n", + "\n", + " assert input_hash not in puzzle_labels[name]\n", + " puzzle_labels[name][input_hash] = label_hash\n", + " \n", + " print (\"Number of puzzles\", len(puzzle_labels))\n", + " \n", + " # Argmax prediction\n", + " preds = all_preds[\"logits\"].argmax(-1)\n", + "\n", + " # Collate\n", + " pred_answers = {}\n", + " for identifier, input, pred, q in zip(all_preds[\"puzzle_identifiers\"], all_preds[\"inputs\"], preds, all_preds[\"q_halt_logits\"].sigmoid()):\n", + " name = identifier_map[identifier]\n", + " orig_name = name.split(\"_\")[0]\n", + " \n", + " input = input.numpy()\n", + " input_hash = grid_hash(inverse_aug(name, crop(input)))\n", + " assert input_hash in puzzle_labels[orig_name]\n", + " \n", + " pred = inverse_aug(name, crop(pred.numpy()))\n", + " pred_hash = grid_hash(pred)\n", + " global_hmap[pred_hash] = pred\n", + " \n", + " pred_answers.setdefault(orig_name, {})\n", + " pred_answers[orig_name].setdefault(input_hash, [])\n", + " pred_answers[orig_name][input_hash].append((pred_hash, q.item()))\n", + "\n", + " # test-1\n", + " if visualize:\n", + " num_figs = sum(len(tests) for name, tests in puzzle_labels.items())\n", + " fig, axes = plt.subplots(num_figs, 4, figsize=(8, num_figs * 4))\n", + " \n", + " fig_id = 0\n", + " \n", + " correct = [0 for _ in range(len(Ks))]\n", + " for name, tests in puzzle_labels.items():\n", + " num_test_correct = [0 for _ in range(len(Ks))]\n", + " for input_hash, label_hash in tests.items():\n", + " p = pred_answers[name][input_hash]\n", + " p_map = {}\n", + " \n", + " for h, q in p:\n", + " p_map.setdefault(h, [0, 0])\n", + " p_map[h][0] += 1\n", + " p_map[h][1] += q\n", + " \n", + " for h, stats in p_map.items():\n", + " stats[1] /= stats[0]\n", + " \n", + " p_map = sorted(p_map.items(), key=lambda kv: kv[1], reverse=True)\n", + "\n", + " # 2-vote\n", + " for i, k in enumerate(Ks):\n", + " ok = False\n", + " for h, stats in p_map[:k]:\n", + " ok |= h == label_hash\n", + " \n", + " num_test_correct[i] += ok\n", + "\n", + " if visualize:\n", + " # Show input and ground truth\n", + " axes[fig_id, 0].imshow(global_hmap[input_hash], cmap=ARC_COLOR_MAP)\n", + " axes[fig_id, 0].set_title(f\"{name}\\nInput\")\n", + " axes[fig_id, 0].axis('off')\n", + " \n", + " axes[fig_id, 1].imshow(global_hmap[label_hash], cmap=ARC_COLOR_MAP)\n", + " axes[fig_id, 1].set_title(f\"{name}\\nAnswer\")\n", + " axes[fig_id, 1].axis('off')\n", + " \n", + " trial_id = 2\n", + " for h, stats in p_map[:2]:\n", + " ans = global_hmap[h]\n", + " \n", + " axes[fig_id, trial_id].imshow(ans, cmap=ARC_COLOR_MAP)\n", + " axes[fig_id, trial_id].set_title(f\"{name}\\nTrial {trial_id}\")\n", + " axes[fig_id, trial_id].axis('off')\n", + " \n", + " trial_id += 1\n", + " \n", + " fig_id += 1\n", + " \n", + " # Total correctness\n", + " for i in range(len(Ks)):\n", + " correct[i] += num_test_correct[i] == len(tests)\n", + "\n", + " for i, k in enumerate(Ks):\n", + " print (f\"{k}-shot: {correct[i] / len(puzzle_labels) * 100:.2f}%\")\n", + "\n", + "\n", + "test(visualize=False)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/srm/assets/npyjs.js b/srm/assets/npyjs.js new file mode 100644 index 0000000..b474575 --- /dev/null +++ b/srm/assets/npyjs.js @@ -0,0 +1,176 @@ +class npyjs { + + constructor(opts) { + if (opts && !('convertFloat16' in opts)) { + console.warn([ + "npyjs constructor now accepts {convertFloat16?: boolean}.", + "For usage, go to https://github.com/jhuapl-boss/npyjs." + ].join(" ")); + } + + this.convertFloat16 = opts?.convertFloat16 ?? true; + + this.dtypes = { + "<u1": { + name: "uint8", + size: 8, + arrayConstructor: Uint8Array, + }, + "|u1": { + name: "uint8", + size: 8, + arrayConstructor: Uint8Array, + }, + "<u2": { + name: "uint16", + size: 16, + arrayConstructor: Uint16Array, + }, + "|i1": { + name: "int8", + size: 8, + arrayConstructor: Int8Array, + }, + "<i2": { + name: "int16", + size: 16, + arrayConstructor: Int16Array, + }, + "<u4": { + name: "uint32", + size: 32, + arrayConstructor: Uint32Array, + }, + "<i4": { + name: "int32", + size: 32, + arrayConstructor: Int32Array, + }, + "<u8": { + name: "uint64", + size: 64, + arrayConstructor: BigUint64Array, + }, + "<i8": { + name: "int64", + size: 64, + arrayConstructor: BigInt64Array, + }, + "<f4": { + name: "float32", + size: 32, + arrayConstructor: Float32Array + }, + "<f8": { + name: "float64", + size: 64, + arrayConstructor: Float64Array + }, + "<f2": { + name: "float16", + size: 16, + arrayConstructor: Uint16Array, + converter: this.convertFloat16 ? this.float16ToFloat32Array : undefined + }, + }; + } + + float16ToFloat32Array(float16Array) { + const length = float16Array.length; + const float32Array = new Float32Array(length); + + for (let i = 0; i < length; i++) { + float32Array[i] = npyjs.float16ToFloat32(float16Array[i]); + } + + return float32Array; + } + + static float16ToFloat32(float16) { + // Extract the parts of the float16 + const sign = (float16 >> 15) & 0x1; + const exponent = (float16 >> 10) & 0x1f; + const fraction = float16 & 0x3ff; + + // Handle special cases + if (exponent === 0) { + if (fraction === 0) { + // Zero + return sign ? -0 : 0; + } + // Denormalized number + return (sign ? -1 : 1) * Math.pow(2, -14) * (fraction / 0x400); + } else if (exponent === 0x1f) { + if (fraction === 0) { + // Infinity + return sign ? -Infinity : Infinity; + } + // NaN + return NaN; + } + + // Normalized number + return (sign ? -1 : 1) * Math.pow(2, exponent - 15) * (1 + fraction / 0x400); + } + + parse(arrayBufferContents) { + // const version = arrayBufferContents.slice(6, 8); // Uint8-encoded + const headerLength = new DataView(arrayBufferContents.slice(8, 10)).getUint8(0); + const offsetBytes = 10 + headerLength; + + const hcontents = new TextDecoder("utf-8").decode( + new Uint8Array(arrayBufferContents.slice(10, 10 + headerLength)) + ); + const header = JSON.parse( + hcontents + .toLowerCase() // True -> true + .replace(/'/g, '"') + .replace("(", "[") + .replace(/,*\),*/g, "]") + ); + const shape = header.shape; + const dtype = this.dtypes[header.descr]; + + if (!dtype) { + console.error(`Unsupported dtype: ${header.descr}`); + return null; + } + + const nums = new dtype.arrayConstructor( + arrayBufferContents, + offsetBytes + ); + + // Convert float16 to float32 if converter exists + const data = dtype.converter ? dtype.converter.call(this, nums) : nums; + + return { + dtype: dtype.name, + data: data, + shape, + fortranOrder: header.fortran_order + }; + } + + async load(filename, callback, fetchArgs) { + /* + Loads an array from a stream of bytes. + */ + fetchArgs = fetchArgs || {}; + let arrayBuf; + // If filename is ArrayBuffer + if (filename instanceof ArrayBuffer) { + arrayBuf = filename; + } + // If filename is a file path + else { + const resp = await fetch(filename, { ...fetchArgs }); + arrayBuf = await resp.arrayBuffer(); + } + const result = this.parse(arrayBuf); + if (callback) { + return callback(result); + } + return result; + } +} diff --git a/srm/config/arch/hrm_v1.yaml b/srm/config/arch/hrm_v1.yaml new file mode 100644 index 0000000..a5646b8 --- /dev/null +++ b/srm/config/arch/hrm_v1.yaml @@ -0,0 +1,21 @@ +name: hrm.hrm_act_v1@HierarchicalReasoningModel_ACTV1 +loss: + name: losses@ACTLossHead + loss_type: stablemax_cross_entropy + +halt_exploration_prob: 0.1 +halt_max_steps: 16 + +H_cycles: 2 +L_cycles: 2 + +H_layers: 4 +L_layers: 4 + +hidden_size: 512 +num_heads: 8 # min(2, hidden_size // 64) +expansion: 4 + +puzzle_emb_ndim: ${.hidden_size} + +pos_encodings: rope diff --git a/srm/config/arch/srm_v1.yaml b/srm/config/arch/srm_v1.yaml new file mode 100644 index 0000000..1b5ece5 --- /dev/null +++ b/srm/config/arch/srm_v1.yaml @@ -0,0 +1,21 @@ +name: srm.srm_aol_v1@StableRecursionModel_ACTV1 +loss: + name: losses@ACTLossHead + loss_type: stablemax_cross_entropy + +halt_exploration_prob: 0.1 +halt_max_steps: 16 + +# SRM-specific +n_iters: 12 # joint micro-steps per ACT step (≈ HRM's H_cycles·L_cycles+H_cycles = 6 with deeper schedule) +n_aol_layers: 2 # depth of AOL ψ block (channel + token mix per layer) +kappa: 0.9 # contraction factor: per-step Lip_P ≤ (1-α)+α·κ = κ +eta: 1.0 # weighting of L block in P-norm (1.0 = symmetric) +alpha: 1.0 # damping (1.0 = full step) + +hidden_size: 512 +puzzle_emb_ndim: ${.hidden_size} + +# Unused (kept so pretrain.py's __pydantic_extra__ doesn't break) +# pretrain.py's create_model() passes some fields HRM expects; Pydantic 'ignore' +# (default) drops them silently. diff --git a/srm/config/cfg_pretrain.yaml b/srm/config/cfg_pretrain.yaml new file mode 100644 index 0000000..51c55a0 --- /dev/null +++ b/srm/config/cfg_pretrain.yaml @@ -0,0 +1,31 @@ +# ARC training config + +defaults: + - arch: hrm_v1 + - _self_ + +hydra: + output_subdir: null + +# Data path +data_path: data/arc-aug-1000 + +# Hyperparams - Training +global_batch_size: 768 + +epochs: 100000 +eval_interval: 10000 +checkpoint_every_eval: True + +lr: 1e-4 +lr_min_ratio: 1.0 +lr_warmup_steps: 2000 + +# Standard hyperparameter settings for LM, as used in Llama +beta1: 0.9 +beta2: 0.95 +weight_decay: 0.1 +puzzle_emb_weight_decay: 0.1 + +# Hyperparams - Puzzle embeddings training +puzzle_emb_lr: 1e-2 diff --git a/srm/dataset/build_arc_dataset.py b/srm/dataset/build_arc_dataset.py new file mode 100644 index 0000000..2da5703 --- /dev/null +++ b/srm/dataset/build_arc_dataset.py @@ -0,0 +1,291 @@ +from typing import List, Optional, Tuple, Dict +from dataclasses import dataclass +from pathlib import Path +import os +import json +import hashlib +import numpy as np +from glob import glob + +from argdantic import ArgParser +from pydantic import BaseModel + +from common import PuzzleDatasetMetadata, dihedral_transform + + +cli = ArgParser() + + +class DataProcessConfig(BaseModel): + # ARC-1 + dataset_dirs: List[str] = ["dataset/raw-data/ARC-AGI/data", "dataset/raw-data/ConceptARC/corpus"] + output_dir: str = "data/arc-aug-1000" + + # ARC-2 + # dataset_dirs: List[str] = ["dataset/raw-data/ARC-AGI-2/data"] + # output_dir: str = "data/arc-2-aug-1000" + + seed: int = 42 + num_aug: int = 1000 + + +ARCMaxGridSize = 30 +ARCAugmentRetriesFactor = 5 + + +@dataclass +class ARCPuzzle: + id: str + + examples: List[Tuple[np.ndarray, np.ndarray]] + + +def arc_grid_to_np(grid: List[List[int]]): + arr = np.array(grid) + + # Shape check + assert arr.ndim == 2 + assert arr.shape[0] <= ARCMaxGridSize and arr.shape[1] <= ARCMaxGridSize + # Element check + assert np.all((arr >= 0) & (arr <= 9)) + return arr.astype(np.uint8) + + +def np_grid_to_seq_translational_augment(inp: np.ndarray, out: np.ndarray, do_translation: bool): + # PAD: 0, <eos>: 1, digits: 2 ... 11 + # Compute random top-left pad + if do_translation: + pad_r = np.random.randint(0, ARCMaxGridSize - max(inp.shape[0], out.shape[0]) + 1) + pad_c = np.random.randint(0, ARCMaxGridSize - max(inp.shape[1], out.shape[1]) + 1) + else: + pad_r = pad_c = 0 + + # Pad grid + result = [] + for grid in [inp, out]: + nrow, ncol = grid.shape + grid = np.pad(grid + 2, ((pad_r, ARCMaxGridSize - pad_r - nrow), (pad_c, ARCMaxGridSize - pad_c - ncol)), constant_values=0) + + # Add <eos> + eos_row, eos_col = pad_r + nrow, pad_c + ncol + if eos_row < ARCMaxGridSize: + grid[eos_row, pad_c:eos_col] = 1 + if eos_col < ARCMaxGridSize: + grid[pad_r:eos_row, eos_col] = 1 + + result.append(grid.flatten()) + + return result + + +def puzzle_hash(puzzle: dict): + # Hash the puzzle for checking equivalence + def _grid_hash(grid: np.ndarray): + buffer = [x.to_bytes(1) for x in grid.shape] + buffer.append(grid.tobytes()) + + return hashlib.sha256(b"".join(buffer)).hexdigest() + + hashes = [] + for example_type, example in puzzle.items(): + for input, label in example.examples: + hashes.append(f"{_grid_hash(input)}|{_grid_hash(label)}") + + hashes.sort() + return hashlib.sha256("|".join(hashes).encode()).hexdigest() + + +def convert_single_arc_puzzle(results: dict, default_name: str, puzzle: dict, aug_count: int, dest_mapping: Dict[str, Tuple[str, str]]): + # Remove "name" + name = puzzle.pop("name", default_name) + + # Convert + dests = set(dest_mapping.values()) + converted = {dest: ARCPuzzle(name, []) for dest in dests} + for example_type, examples in puzzle.items(): + dest = dest_mapping[example_type] + converted[dest].examples.extend([(arc_grid_to_np(example["input"]), arc_grid_to_np(example["output"])) for example in examples]) + + group = [converted] + + # Augment + if aug_count > 0: + hashes = {puzzle_hash(converted)} + + for _trial in range(ARCAugmentRetriesFactor * aug_count): + # Augment plan + trans_id = np.random.randint(0, 8) + mapping = np.concatenate([np.arange(0, 1, dtype=np.uint8), np.random.permutation(np.arange(1, 10, dtype=np.uint8))]) # Permute colors, Excluding "0" (black) + + aug_repr = f"t{trans_id}_{''.join(str(x) for x in mapping)}" + + def _map_grid(grid: np.ndarray): + return dihedral_transform(mapping[grid], trans_id) + + # Check duplicate + augmented = {dest: ARCPuzzle(f"{puzzle.id}_{aug_repr}", [(_map_grid(input), _map_grid(label)) for (input, label) in puzzle.examples]) for dest, puzzle in converted.items()} + h = puzzle_hash(augmented) + if h not in hashes: + hashes.add(h) + group.append(augmented) + + if len(group) >= aug_count + 1: + break + + if len(group) < aug_count + 1: + print (f"[Puzzle {name}] augmentation not full, only {len(group)}") + + # Append + for dest in dests: + # Convert the examples + dest_split, dest_set = dest + + results.setdefault(dest_split, {}) + results[dest_split].setdefault(dest_set, []) + results[dest_split][dest_set].append([converted[dest] for converted in group]) + + +def load_puzzles_arcagi(results: dict, dataset_path: str, config: DataProcessConfig): + train_examples_dest = ("train", "all") + test_examples_map = { + "evaluation": [(1.0, ("test", "all"))], + "_default": [(1.0, ("train", "all"))] + } + + total_puzzles = 0 + for subdir in os.scandir(dataset_path): + if subdir.is_dir(): + # Load all puzzles in this directory + puzzles = [] + for filename in glob(os.path.join(subdir.path, "*.json")): + with open(filename, "r") as f: + puzzles.append((Path(filename).stem, json.load(f))) + + # Shuffle puzzles + np.random.shuffle(puzzles) + + # Assign by fraction + for idx, (default_name, puzzle) in enumerate(puzzles): + fraction = idx / len(puzzles) + test_examples_dest = None + for f, dest in test_examples_map.get(subdir.name, test_examples_map["_default"]): + if fraction < f: + test_examples_dest = dest + break + + assert test_examples_dest is not None + + convert_single_arc_puzzle(results, default_name, puzzle, config.num_aug, {"train": train_examples_dest, "test": test_examples_dest}) + total_puzzles += 1 + + print (f"[{dataset_path}] total puzzles: {total_puzzles}") + + +def convert_dataset(config: DataProcessConfig): + np.random.seed(config.seed) + + # Read dataset + data = {} + for dataset_dir in config.dataset_dirs: + load_puzzles_arcagi(data, dataset_dir, config) + + # Map global puzzle identifiers + num_identifiers = 1 # 0 is blank + identifier_map = {} + for split_name, split in data.items(): + for subset_name, subset in split.items(): + for group in subset: + for puzzle in group: + if puzzle.id not in identifier_map: + identifier_map[puzzle.id] = num_identifiers + num_identifiers += 1 + + print (f"Total puzzle IDs (including <blank>): {num_identifiers}") + + # Save + for split_name, split in data.items(): + os.makedirs(os.path.join(config.output_dir, split_name), exist_ok=True) + + # Translational augmentations + enable_translational_augment = split_name == "train" + + # Statistics + total_examples = 0 + total_puzzles = 0 + total_groups = 0 + + for subset_name, subset in split.items(): + # Construct subset + results = {k: [] for k in ["inputs", "labels", "puzzle_identifiers", "puzzle_indices", "group_indices"]} + results["puzzle_indices"].append(0) + results["group_indices"].append(0) + + example_id = 0 + puzzle_id = 0 + + for group in subset: + for puzzle in group: + # Push puzzle + no_aug_id = np.random.randint(0, len(puzzle.examples)) + for _idx_ex, (inp, out) in enumerate(puzzle.examples): + inp, out = np_grid_to_seq_translational_augment(inp, out, do_translation=enable_translational_augment and _idx_ex != no_aug_id) + + results["inputs"].append(inp) + results["labels"].append(out) + example_id += 1 + + total_examples += 1 + + results["puzzle_indices"].append(example_id) + results["puzzle_identifiers"].append(identifier_map[puzzle.id]) + + puzzle_id += 1 + + total_puzzles += 1 + + # Push group + results["group_indices"].append(puzzle_id) + total_groups += 1 + + for k, v in results.items(): + if k in {"inputs", "labels"}: + v = np.stack(v, 0) + else: + v = np.array(v, dtype=np.int32) + + np.save(os.path.join(config.output_dir, split_name, f"{subset_name}__{k}.npy"), v) + + # Metadata + metadata = PuzzleDatasetMetadata( + seq_len=ARCMaxGridSize * ARCMaxGridSize, + vocab_size=10 + 2, # PAD + EOS + "0" ... "9" + + pad_id=0, + ignore_label_id=0, + + blank_identifier_id=0, + num_puzzle_identifiers=num_identifiers, + + total_groups=total_groups, + mean_puzzle_examples=total_examples / total_puzzles, + sets=list(split.keys()) + ) + + # Save metadata as JSON. + with open(os.path.join(config.output_dir, split_name, "dataset.json"), "w") as f: + json.dump(metadata.model_dump(), f) + + # Save IDs mapping + with open(os.path.join(config.output_dir, "identifiers.json"), "w") as f: + ids_mapping = {v: k for k, v in identifier_map.items()} + + json.dump([ids_mapping.get(i, "<blank>") for i in range(num_identifiers)], f) + + +@cli.command(singleton=True) +def main(config: DataProcessConfig): + convert_dataset(config) + + +if __name__ == "__main__": + cli() diff --git a/srm/dataset/build_maze_dataset.py b/srm/dataset/build_maze_dataset.py new file mode 100644 index 0000000..a9367f3 --- /dev/null +++ b/srm/dataset/build_maze_dataset.py @@ -0,0 +1,142 @@ +from typing import Optional +import math +import os +import csv +import json +import numpy as np + +from argdantic import ArgParser +from pydantic import BaseModel +from tqdm import tqdm +from huggingface_hub import hf_hub_download + +from common import PuzzleDatasetMetadata, dihedral_transform + + +CHARSET = "# SGo" + + +cli = ArgParser() + + +class DataProcessConfig(BaseModel): + source_repo: str = "sapientinc/maze-30x30-hard-1k" + output_dir: str = "data/maze-30x30-hard-1k" + + subsample_size: Optional[int] = None + aug: bool = False + + +def convert_subset(set_name: str, config: DataProcessConfig): + # Read CSV + all_chars = set() + grid_size = None + inputs = [] + labels = [] + + with open(hf_hub_download(config.source_repo, f"{set_name}.csv", repo_type="dataset"), newline="") as csvfile: # type: ignore + reader = csv.reader(csvfile) + next(reader) # Skip header + for source, q, a, rating in reader: + all_chars.update(q) + all_chars.update(a) + + if grid_size is None: + n = int(len(q) ** 0.5) + grid_size = (n, n) + + inputs.append(np.frombuffer(q.encode(), dtype=np.uint8).reshape(grid_size)) + labels.append(np.frombuffer(a.encode(), dtype=np.uint8).reshape(grid_size)) + + # If subsample_size is specified for the training set, + # randomly sample the desired number of examples. + if set_name == "train" and config.subsample_size is not None: + total_samples = len(inputs) + if config.subsample_size < total_samples: + indices = np.random.choice(total_samples, size=config.subsample_size, replace=False) + inputs = [inputs[i] for i in indices] + labels = [labels[i] for i in indices] + + # Generate dataset + results = {k: [] for k in ["inputs", "labels", "puzzle_identifiers", "puzzle_indices", "group_indices"]} + puzzle_id = 0 + example_id = 0 + + results["puzzle_indices"].append(0) + results["group_indices"].append(0) + + for inp, out in zip(tqdm(inputs), labels): + # Dihedral transformations for augmentation + for aug_idx in range(8 if (set_name == "train" and config.aug) else 1): + results["inputs"].append(dihedral_transform(inp, aug_idx)) + results["labels"].append(dihedral_transform(out, aug_idx)) + example_id += 1 + puzzle_id += 1 + + results["puzzle_indices"].append(example_id) + results["puzzle_identifiers"].append(0) + + # Push group + results["group_indices"].append(puzzle_id) + + # Char mappings + assert len(all_chars - set(CHARSET)) == 0 + + char2id = np.zeros(256, np.uint8) + char2id[np.array(list(map(ord, CHARSET)))] = np.arange(len(CHARSET)) + 1 + + # To Numpy + def _seq_to_numpy(seq): + arr = np.vstack([char2id[s.reshape(-1)] for s in seq]) + + return arr + + results = { + "inputs": _seq_to_numpy(results["inputs"]), + "labels": _seq_to_numpy(results["labels"]), + + "group_indices": np.array(results["group_indices"], dtype=np.int32), + "puzzle_indices": np.array(results["puzzle_indices"], dtype=np.int32), + "puzzle_identifiers": np.array(results["puzzle_identifiers"], dtype=np.int32), + } + + # Metadata + metadata = PuzzleDatasetMetadata( + seq_len=int(math.prod(grid_size)), # type: ignore + vocab_size=len(CHARSET) + 1, # PAD + Charset + + pad_id=0, + ignore_label_id=0, + + blank_identifier_id=0, + num_puzzle_identifiers=1, + + total_groups=len(results["group_indices"]) - 1, + mean_puzzle_examples=1, + sets=["all"] + ) + + # Save metadata as JSON. + save_dir = os.path.join(config.output_dir, set_name) + os.makedirs(save_dir, exist_ok=True) + + with open(os.path.join(save_dir, "dataset.json"), "w") as f: + json.dump(metadata.model_dump(), f) + + # Save data + for k, v in results.items(): + np.save(os.path.join(save_dir, f"all__{k}.npy"), v) + + # Save IDs mapping (for visualization only) + with open(os.path.join(config.output_dir, "identifiers.json"), "w") as f: + json.dump(["<blank>"], f) + + +@cli.command(singleton=True) +def preprocess_data(config: DataProcessConfig): + convert_subset("train", config) + convert_subset("test", config) + + +if __name__ == "__main__": + cli() diff --git a/srm/dataset/build_sudoku_dataset.py b/srm/dataset/build_sudoku_dataset.py new file mode 100644 index 0000000..7924438 --- /dev/null +++ b/srm/dataset/build_sudoku_dataset.py @@ -0,0 +1,169 @@ +from typing import Optional +import os +import csv +import json +import numpy as np + +from argdantic import ArgParser +from pydantic import BaseModel +from tqdm import tqdm +from huggingface_hub import hf_hub_download + +from common import PuzzleDatasetMetadata + + +cli = ArgParser() + + +class DataProcessConfig(BaseModel): + source_repo: str = "sapientinc/sudoku-extreme" + output_dir: str = "data/sudoku-extreme-full" + + subsample_size: Optional[int] = None + min_difficulty: Optional[int] = None + num_aug: int = 0 + + +def shuffle_sudoku(board: np.ndarray, solution: np.ndarray): + # Create a random digit mapping: a permutation of 1..9, with zero (blank) unchanged + digit_map = np.pad(np.random.permutation(np.arange(1, 10)), (1, 0)) + + # Randomly decide whether to transpose. + transpose_flag = np.random.rand() < 0.5 + + # Generate a valid row permutation: + # - Shuffle the 3 bands (each band = 3 rows) and for each band, shuffle its 3 rows. + bands = np.random.permutation(3) + row_perm = np.concatenate([b * 3 + np.random.permutation(3) for b in bands]) + + # Similarly for columns (stacks). + stacks = np.random.permutation(3) + col_perm = np.concatenate([s * 3 + np.random.permutation(3) for s in stacks]) + + # Build an 81->81 mapping. For each new cell at (i, j) + # (row index = i // 9, col index = i % 9), + # its value comes from old row = row_perm[i//9] and old col = col_perm[i%9]. + mapping = np.array([row_perm[i // 9] * 9 + col_perm[i % 9] for i in range(81)]) + + def apply_transformation(x: np.ndarray) -> np.ndarray: + # Apply transpose flag + if transpose_flag: + x = x.T + # Apply the position mapping. + new_board = x.flatten()[mapping].reshape(9, 9).copy() + # Apply digit mapping + return digit_map[new_board] + + return apply_transformation(board), apply_transformation(solution) + + +def convert_subset(set_name: str, config: DataProcessConfig): + # Read CSV + inputs = [] + labels = [] + + with open(hf_hub_download(config.source_repo, f"{set_name}.csv", repo_type="dataset"), newline="") as csvfile: + reader = csv.reader(csvfile) + next(reader) # Skip header + for source, q, a, rating in reader: + if (config.min_difficulty is None) or (int(rating) >= config.min_difficulty): + assert len(q) == 81 and len(a) == 81 + + inputs.append(np.frombuffer(q.replace('.', '0').encode(), dtype=np.uint8).reshape(9, 9) - ord('0')) + labels.append(np.frombuffer(a.encode(), dtype=np.uint8).reshape(9, 9) - ord('0')) + + # If subsample_size is specified for the training set, + # randomly sample the desired number of examples. + if set_name == "train" and config.subsample_size is not None: + total_samples = len(inputs) + if config.subsample_size < total_samples: + indices = np.random.choice(total_samples, size=config.subsample_size, replace=False) + inputs = [inputs[i] for i in indices] + labels = [labels[i] for i in indices] + + # Generate dataset + num_augments = config.num_aug if set_name == "train" else 0 + + results = {k: [] for k in ["inputs", "labels", "puzzle_identifiers", "puzzle_indices", "group_indices"]} + puzzle_id = 0 + example_id = 0 + + results["puzzle_indices"].append(0) + results["group_indices"].append(0) + + for orig_inp, orig_out in zip(tqdm(inputs), labels): + for aug_idx in range(1 + num_augments): + # First index is not augmented + if aug_idx == 0: + inp, out = orig_inp, orig_out + else: + inp, out = shuffle_sudoku(orig_inp, orig_out) + + # Push puzzle (only single example) + results["inputs"].append(inp) + results["labels"].append(out) + example_id += 1 + puzzle_id += 1 + + results["puzzle_indices"].append(example_id) + results["puzzle_identifiers"].append(0) + + # Push group + results["group_indices"].append(puzzle_id) + + # To Numpy + def _seq_to_numpy(seq): + arr = np.concatenate(seq).reshape(len(seq), -1) + + assert np.all((arr >= 0) & (arr <= 9)) + return arr + 1 + + results = { + "inputs": _seq_to_numpy(results["inputs"]), + "labels": _seq_to_numpy(results["labels"]), + + "group_indices": np.array(results["group_indices"], dtype=np.int32), + "puzzle_indices": np.array(results["puzzle_indices"], dtype=np.int32), + "puzzle_identifiers": np.array(results["puzzle_identifiers"], dtype=np.int32), + } + + # Metadata + metadata = PuzzleDatasetMetadata( + seq_len=81, + vocab_size=10 + 1, # PAD + "0" ... "9" + + pad_id=0, + ignore_label_id=0, + + blank_identifier_id=0, + num_puzzle_identifiers=1, + + total_groups=len(results["group_indices"]) - 1, + mean_puzzle_examples=1, + sets=["all"] + ) + + # Save metadata as JSON. + save_dir = os.path.join(config.output_dir, set_name) + os.makedirs(save_dir, exist_ok=True) + + with open(os.path.join(save_dir, "dataset.json"), "w") as f: + json.dump(metadata.model_dump(), f) + + # Save data + for k, v in results.items(): + np.save(os.path.join(save_dir, f"all__{k}.npy"), v) + + # Save IDs mapping (for visualization only) + with open(os.path.join(config.output_dir, "identifiers.json"), "w") as f: + json.dump(["<blank>"], f) + + +@cli.command(singleton=True) +def preprocess_data(config: DataProcessConfig): + convert_subset("train", config) + convert_subset("test", config) + + +if __name__ == "__main__": + cli() diff --git a/srm/dataset/common.py b/srm/dataset/common.py new file mode 100644 index 0000000..7bc51c6 --- /dev/null +++ b/srm/dataset/common.py @@ -0,0 +1,51 @@ +from typing import List, Optional + +import pydantic +import numpy as np + + +# Global list mapping each dihedral transform id to its inverse. +# Index corresponds to the original tid, and the value is its inverse. +DIHEDRAL_INVERSE = [0, 3, 2, 1, 4, 5, 6, 7] + + +class PuzzleDatasetMetadata(pydantic.BaseModel): + pad_id: int + ignore_label_id: Optional[int] + blank_identifier_id: int + + vocab_size: int + seq_len: int + num_puzzle_identifiers: int + + total_groups: int + mean_puzzle_examples: float + + sets: List[str] + + +def dihedral_transform(arr: np.ndarray, tid: int) -> np.ndarray: + """8 dihedral symmetries by rotate, flip and mirror""" + + if tid == 0: + return arr # identity + elif tid == 1: + return np.rot90(arr, k=1) + elif tid == 2: + return np.rot90(arr, k=2) + elif tid == 3: + return np.rot90(arr, k=3) + elif tid == 4: + return np.fliplr(arr) # horizontal flip + elif tid == 5: + return np.flipud(arr) # vertical flip + elif tid == 6: + return arr.T # transpose (reflection along main diagonal) + elif tid == 7: + return np.fliplr(np.rot90(arr, k=1)) # anti-diagonal reflection + else: + return arr + + +def inverse_dihedral_transform(arr: np.ndarray, tid: int) -> np.ndarray: + return dihedral_transform(arr, DIHEDRAL_INVERSE[tid]) diff --git a/srm/evaluate.py b/srm/evaluate.py new file mode 100644 index 0000000..71ee753 --- /dev/null +++ b/srm/evaluate.py @@ -0,0 +1,68 @@ +from typing import List +import yaml +import os + +import torch +import torch.distributed as dist + +import pydantic +from omegaconf import OmegaConf +from pretrain import PretrainConfig, init_train_state, evaluate, create_dataloader + + +class EvalConfig(pydantic.BaseModel): + checkpoint: str + + save_outputs: List[str] = ["inputs", "labels", "puzzle_identifiers", "logits", "q_halt_logits", "q_continue_logits"] + + +def launch(): + eval_cfg = EvalConfig(**OmegaConf.to_container(OmegaConf.from_cli())) # type: ignore + + RANK = 0 + WORLD_SIZE = 1 + # Initialize distributed training if in distributed environment (e.g. torchrun) + if "LOCAL_RANK" in os.environ: + # Initialize distributed, default device and dtype + dist.init_process_group(backend="nccl") + + RANK = dist.get_rank() + WORLD_SIZE = dist.get_world_size() + + torch.cuda.set_device(int(os.environ["LOCAL_RANK"])) + + with open(os.path.join(os.path.dirname(eval_cfg.checkpoint), "all_config.yaml"), "r") as f: + config = PretrainConfig(**yaml.safe_load(f)) + + config.eval_save_outputs = eval_cfg.save_outputs + config.checkpoint_path = os.path.dirname(eval_cfg.checkpoint) + + # Dataloader + train_loader, train_metadata = create_dataloader(config, "train", test_set_mode=False, epochs_per_iter=1, global_batch_size=config.global_batch_size, rank=RANK, world_size=WORLD_SIZE) + eval_loader, eval_metadata = create_dataloader(config, "test", test_set_mode=True, epochs_per_iter=1, global_batch_size=config.global_batch_size, rank=RANK, world_size=WORLD_SIZE) + + # Models + train_state = init_train_state(config, train_metadata, world_size=WORLD_SIZE) + # Try unwrap torch.compile + try: + train_state.model.load_state_dict(torch.load(eval_cfg.checkpoint, map_location="cuda"), assign=True) + except: + train_state.model.load_state_dict({k.removeprefix("_orig_mod."): v for k, v in torch.load(eval_cfg.checkpoint, map_location="cuda").items()}, assign=True) + + train_state.step = 0 + ckpt_filename = os.path.basename(eval_cfg.checkpoint) + if ckpt_filename.startswith("step_"): + train_state.step = int(ckpt_filename.removeprefix("step_")) + + # Evaluate + print ("Starting evaluation") + + train_state.model.eval() + metrics = evaluate(config, train_state, eval_loader, eval_metadata, rank=RANK, world_size=WORLD_SIZE) + + if metrics is not None: + print (metrics) + + +if __name__ == "__main__": + launch() diff --git a/srm/models/common.py b/srm/models/common.py new file mode 100644 index 0000000..1a04505 --- /dev/null +++ b/srm/models/common.py @@ -0,0 +1,32 @@ +import math + +import torch +from torch import nn + + +def trunc_normal_init_(tensor: torch.Tensor, std: float = 1.0, lower: float = -2.0, upper: float = 2.0): + # NOTE: PyTorch nn.init.trunc_normal_ is not mathematically correct, the std dev is not actually the std dev of initialized tensor + # This function is a PyTorch version of jax truncated normal init (default init method in flax) + # https://github.com/jax-ml/jax/blob/main/jax/_src/random.py#L807-L848 + # https://github.com/jax-ml/jax/blob/main/jax/_src/nn/initializers.py#L162-L199 + + with torch.no_grad(): + if std == 0: + tensor.zero_() + else: + sqrt2 = math.sqrt(2) + a = math.erf(lower / sqrt2) + b = math.erf(upper / sqrt2) + z = (b - a) / 2 + + c = (2 * math.pi) ** -0.5 + pdf_u = c * math.exp(-0.5 * lower ** 2) + pdf_l = c * math.exp(-0.5 * upper ** 2) + comp_std = std / math.sqrt(1 - (upper * pdf_u - lower * pdf_l) / z - ((pdf_u - pdf_l) / z) ** 2) + + tensor.uniform_(a, b) + tensor.erfinv_() + tensor.mul_(sqrt2 * comp_std) + tensor.clip_(lower * comp_std, upper * comp_std) + + return tensor diff --git a/srm/models/hrm/hrm_act_v1.py b/srm/models/hrm/hrm_act_v1.py new file mode 100644 index 0000000..e91c7d1 --- /dev/null +++ b/srm/models/hrm/hrm_act_v1.py @@ -0,0 +1,283 @@ +from typing import Tuple, List, Dict, Optional +from dataclasses import dataclass +import math + +import torch +import torch.nn.functional as F +from torch import nn +from pydantic import BaseModel + +from models.common import trunc_normal_init_ +from models.layers import rms_norm, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear +from models.sparse_embedding import CastedSparseEmbedding + + +@dataclass +class HierarchicalReasoningModel_ACTV1InnerCarry: + z_H: torch.Tensor + z_L: torch.Tensor + + +@dataclass +class HierarchicalReasoningModel_ACTV1Carry: + inner_carry: HierarchicalReasoningModel_ACTV1InnerCarry + + steps: torch.Tensor + halted: torch.Tensor + + current_data: Dict[str, torch.Tensor] + + +class HierarchicalReasoningModel_ACTV1Config(BaseModel): + batch_size: int + seq_len: int + puzzle_emb_ndim: int = 0 + num_puzzle_identifiers: int + vocab_size: int + + H_cycles: int + L_cycles: int + + H_layers: int + L_layers: int + + # Transformer config + hidden_size: int + expansion: float + num_heads: int + pos_encodings: str + + rms_norm_eps: float = 1e-5 + rope_theta: float = 10000.0 + + # Halting Q-learning config + halt_max_steps: int + halt_exploration_prob: float + + forward_dtype: str = "bfloat16" + + +class HierarchicalReasoningModel_ACTV1Block(nn.Module): + def __init__(self, config: HierarchicalReasoningModel_ACTV1Config) -> None: + super().__init__() + + self.self_attn = Attention( + hidden_size=config.hidden_size, + head_dim=config.hidden_size // config.num_heads, + num_heads=config.num_heads, + num_key_value_heads=config.num_heads, + causal=False + ) + self.mlp = SwiGLU( + hidden_size=config.hidden_size, + expansion=config.expansion, + ) + self.norm_eps = config.rms_norm_eps + + def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor: + # Post Norm + # Self Attention + hidden_states = rms_norm(hidden_states + self.self_attn(cos_sin=cos_sin, hidden_states=hidden_states), variance_epsilon=self.norm_eps) + # Fully Connected + hidden_states = rms_norm(hidden_states + self.mlp(hidden_states), variance_epsilon=self.norm_eps) + return hidden_states + + +class HierarchicalReasoningModel_ACTV1ReasoningModule(nn.Module): + def __init__(self, layers: List[HierarchicalReasoningModel_ACTV1Block]): + super().__init__() + + self.layers = torch.nn.ModuleList(layers) + + def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor: + # Input injection (add) + hidden_states = hidden_states + input_injection + # Layers + for layer in self.layers: + hidden_states = layer(hidden_states=hidden_states, **kwargs) + + return hidden_states + + +class HierarchicalReasoningModel_ACTV1_Inner(nn.Module): + def __init__(self, config: HierarchicalReasoningModel_ACTV1Config) -> None: + super().__init__() + self.config = config + self.forward_dtype = getattr(torch, self.config.forward_dtype) + + # I/O + self.embed_scale = math.sqrt(self.config.hidden_size) + embed_init_std = 1.0 / self.embed_scale + + self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype) + self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False) + self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True) + + self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) # ceil div + if self.config.puzzle_emb_ndim > 0: + # Zero init puzzle embeddings + self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim, + batch_size=self.config.batch_size, init_std=0, cast_to=self.forward_dtype) + + # LM Blocks + if self.config.pos_encodings == "rope": + self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads, + max_position_embeddings=self.config.seq_len + self.puzzle_emb_len, + base=self.config.rope_theta) + elif self.config.pos_encodings == "learned": + self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype) + else: + raise NotImplementedError() + + # Reasoning Layers + self.H_level = HierarchicalReasoningModel_ACTV1ReasoningModule(layers=[HierarchicalReasoningModel_ACTV1Block(self.config) for _i in range(self.config.H_layers)]) + self.L_level = HierarchicalReasoningModel_ACTV1ReasoningModule(layers=[HierarchicalReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)]) + + # Initial states + self.H_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True) + self.L_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True) + + # Q head special init + # Init Q to (almost) zero for faster learning during bootstrapping + with torch.no_grad(): + self.q_head.weight.zero_() + self.q_head.bias.fill_(-5) # type: ignore + + def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor): + # Token embedding + embedding = self.embed_tokens(input.to(torch.int32)) + + # Puzzle embeddings + if self.config.puzzle_emb_ndim > 0: + puzzle_embedding = self.puzzle_emb(puzzle_identifiers) + + pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1] + if pad_count > 0: + puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count)) + + embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2) + + # Position embeddings + if self.config.pos_encodings == "learned": + # scale by 1/sqrt(2) to maintain forward variance + embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype)) + + # Scale + return self.embed_scale * embedding + + def empty_carry(self, batch_size: int): + return HierarchicalReasoningModel_ACTV1InnerCarry( + z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype), + z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype), + ) + + def reset_carry(self, reset_flag: torch.Tensor, carry: HierarchicalReasoningModel_ACTV1InnerCarry): + return HierarchicalReasoningModel_ACTV1InnerCarry( + z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H), + z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L), + ) + + def forward(self, carry: HierarchicalReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + seq_info = dict( + cos_sin=self.rotary_emb() if hasattr(self, "rotary_emb") else None, + ) + + # Input encoding + input_embeddings = self._input_embeddings(batch["inputs"], batch["puzzle_identifiers"]) + + # Forward iterations + with torch.no_grad(): + z_H, z_L = carry.z_H, carry.z_L + + for _H_step in range(self.config.H_cycles): + for _L_step in range(self.config.L_cycles): + if not ((_H_step == self.config.H_cycles - 1) and (_L_step == self.config.L_cycles - 1)): + z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info) + + if not (_H_step == self.config.H_cycles - 1): + z_H = self.H_level(z_H, z_L, **seq_info) + + assert not z_H.requires_grad and not z_L.requires_grad + + # 1-step grad + z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info) + z_H = self.H_level(z_H, z_L, **seq_info) + + # LM Outputs + new_carry = HierarchicalReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad + output = self.lm_head(z_H)[:, self.puzzle_emb_len:] + + # Q head + q_logits = self.q_head(z_H[:, 0]).to(torch.float32) + + return new_carry, output, (q_logits[..., 0], q_logits[..., 1]) + + +class HierarchicalReasoningModel_ACTV1(nn.Module): + """ACT wrapper.""" + + def __init__(self, config_dict: dict): + super().__init__() + self.config = HierarchicalReasoningModel_ACTV1Config(**config_dict) + self.inner = HierarchicalReasoningModel_ACTV1_Inner(self.config) + + @property + def puzzle_emb(self): + return self.inner.puzzle_emb + + def initial_carry(self, batch: Dict[str, torch.Tensor]): + batch_size = batch["inputs"].shape[0] + + return HierarchicalReasoningModel_ACTV1Carry( + inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted. + + steps=torch.zeros((batch_size, ), dtype=torch.int32), + halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted + + current_data={k: torch.empty_like(v) for k, v in batch.items()} + ) + + def forward(self, carry: HierarchicalReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]: + # Update data, carry (removing halted sequences) + new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry) + + new_steps = torch.where(carry.halted, 0, carry.steps) + + new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()} + + # Forward inner model + new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data) + + outputs = { + "logits": logits, + "q_halt_logits": q_halt_logits, + "q_continue_logits": q_continue_logits + } + + with torch.no_grad(): + # Step + new_steps = new_steps + 1 + is_last_step = new_steps >= self.config.halt_max_steps + + halted = is_last_step + + # if training, and ACT is enabled + if self.training and (self.config.halt_max_steps > 1): + # Halt signal + # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes + halted = halted | (q_halt_logits > q_continue_logits) + + # Exploration + min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1) + + halted = halted & (new_steps >= min_halt_steps) + + # Compute target Q + # NOTE: No replay buffer and target networks for computing target Q-value. + # As batch_size is large, there're many parallel envs. + # Similar concept as PQN https://arxiv.org/abs/2407.04811 + next_q_halt_logits, next_q_continue_logits = self.inner(new_inner_carry, new_current_data)[-1] + + outputs["target_q_continue"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits))) + + return HierarchicalReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs diff --git a/srm/models/layers.py b/srm/models/layers.py new file mode 100644 index 0000000..0394744 --- /dev/null +++ b/srm/models/layers.py @@ -0,0 +1,157 @@ +from typing import Tuple + +import torch +from torch import nn +import torch.nn.functional as F + +try: + from flash_attn_interface import flash_attn_func # type: ignore[import] +except ImportError: + # Fallback to FlashAttention 2 + from flash_attn import flash_attn_func # type: ignore[import] + +from models.common import trunc_normal_init_ + + +CosSin = Tuple[torch.Tensor, torch.Tensor] + + +def _find_multiple(a, b): + return (-(a // -b)) * b + + +def rotate_half(x: torch.Tensor): + """Rotates half the hidden dims of the input.""" + x1 = x[..., : x.shape[-1] // 2] + x2 = x[..., x.shape[-1] // 2 :] + return torch.cat((-x2, x1), dim=-1) + + +def apply_rotary_pos_emb(q: torch.Tensor, k: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor): + # q, k: [bs, seq_len, num_heads, head_dim] + # cos, sin: [seq_len, head_dim] + orig_dtype = q.dtype + q = q.to(cos.dtype) + k = k.to(cos.dtype) + + q_embed = (q * cos.unsqueeze(-2)) + (rotate_half(q) * sin.unsqueeze(-2)) + k_embed = (k * cos.unsqueeze(-2)) + (rotate_half(k) * sin.unsqueeze(-2)) + + return q_embed.to(orig_dtype), k_embed.to(orig_dtype) + + +class CastedLinear(nn.Module): + def __init__(self, + in_features: int, + out_features: int, + bias: bool): + super().__init__() + # Truncated LeCun normal init + self.weight = nn.Parameter( + trunc_normal_init_(torch.empty((out_features, in_features)), std=1.0 / (in_features ** 0.5)) + ) + self.bias = None + if bias: + # Zero init bias + self.bias = nn.Parameter(torch.zeros((out_features, ))) + + def forward(self, input: torch.Tensor) -> torch.Tensor: + return F.linear(input, self.weight.to(input.dtype), bias=self.bias.to(input.dtype) if self.bias is not None else None) + + +class CastedEmbedding(nn.Module): + def __init__(self, + num_embeddings: int, + embedding_dim: int, + init_std: float, + cast_to: torch.dtype): + super().__init__() + self.cast_to = cast_to + + # Truncated LeCun normal init + self.embedding_weight = nn.Parameter( + trunc_normal_init_(torch.empty((num_embeddings, embedding_dim)), std=init_std) + ) + + def forward(self, input: torch.Tensor) -> torch.Tensor: + return F.embedding(input, self.embedding_weight.to(self.cast_to)) + + +class RotaryEmbedding(nn.Module): + def __init__(self, dim, max_position_embeddings, base, device=None): + super().__init__() + + # RoPE + inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2, dtype=torch.float32, device=device) / dim)) + t = torch.arange(max_position_embeddings, dtype=torch.float32, device=device) + freqs = torch.outer(t, inv_freq) + + # Different from paper, but it uses a different permutation in order to obtain the same calculation + emb = torch.cat((freqs, freqs), dim=-1) + self.cos_cached = nn.Buffer(emb.cos(), persistent=False) + self.sin_cached = nn.Buffer(emb.sin(), persistent=False) + + def forward(self): + return self.cos_cached, self.sin_cached + + +class Attention(nn.Module): + def __init__(self, hidden_size, head_dim, num_heads, num_key_value_heads, causal=False): + super().__init__() + + self.hidden_size = hidden_size + self.head_dim = head_dim + self.output_size = head_dim * num_heads + self.num_heads = num_heads + self.num_key_value_heads = num_key_value_heads + self.causal = causal + + self.qkv_proj = CastedLinear(self.hidden_size, (self.num_heads + 2 * self.num_key_value_heads) * self.head_dim, bias=False) + self.o_proj = CastedLinear(self.output_size, self.hidden_size, bias=False) + + def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor: + batch_size, seq_len, _ = hidden_states.shape + + # hidden_states: [bs, seq_len, num_heads, head_dim] + qkv = self.qkv_proj(hidden_states) + + # Split head + qkv = qkv.view(batch_size, seq_len, self.num_heads + 2 * self.num_key_value_heads, self.head_dim) + query = qkv[:, :, :self.num_heads] + key = qkv[:, :, self.num_heads: self.num_heads + self.num_key_value_heads] + value = qkv[:, :, self.num_heads + self.num_key_value_heads:] + + # RoPE + if cos_sin is not None: + cos, sin = cos_sin + query, key = apply_rotary_pos_emb(query, key, cos, sin) + + # flash attn + attn_output = flash_attn_func(q=query, k=key, v=value, causal=self.causal) + if isinstance(attn_output, tuple): # fa2 and fa3 compatibility + attn_output = attn_output[0] + + attn_output = attn_output.view(batch_size, seq_len, self.output_size) # type: ignore + return self.o_proj(attn_output) + + +class SwiGLU(nn.Module): + def __init__(self, hidden_size: int, expansion: float): + super().__init__() + inter = _find_multiple(round(expansion * hidden_size * 2 / 3), 256) + + self.gate_up_proj = CastedLinear(hidden_size, inter * 2, bias=False) + self.down_proj = CastedLinear(inter, hidden_size, bias=False) + + def forward(self, x): + gate, up = self.gate_up_proj(x).chunk(2, dim=-1) + return self.down_proj(F.silu(gate) * up) + + +def rms_norm(hidden_states: torch.Tensor, variance_epsilon: float) -> torch.Tensor: + input_dtype = hidden_states.dtype + hidden_states = hidden_states.to(torch.float32) + + variance = hidden_states.square().mean(-1, keepdim=True) + hidden_states = hidden_states * torch.rsqrt(variance + variance_epsilon) + return hidden_states.to(input_dtype) diff --git a/srm/models/losses.py b/srm/models/losses.py new file mode 100644 index 0000000..b3118e7 --- /dev/null +++ b/srm/models/losses.py @@ -0,0 +1,101 @@ +from typing import Any, Tuple, Dict, Sequence, Optional + +import torch +import torch.nn.functional as F +from torch import nn + + +IGNORE_LABEL_ID = -100 + + +def s(x, epsilon=1e-30): + return torch.where( + x<0, + 1/(1-x+ epsilon), + x + 1 + ) + + +def log_stablemax(x, dim=-1): + s_x = s(x) + return torch.log(s_x/torch.sum(s_x, dim=dim, keepdim=True)) + + +def stablemax_cross_entropy(logits, labels, ignore_index: int = -100): + logprobs = log_stablemax(logits.to(torch.float64), dim=-1) + + valid_mask = labels != ignore_index + transformed_labels = torch.where(valid_mask, labels, 0) + prediction_logprobs = torch.gather(logprobs, index=transformed_labels.to(torch.long).unsqueeze(-1), dim=-1).squeeze(-1) + + return -torch.where(valid_mask, prediction_logprobs, 0) + + +def softmax_cross_entropy(logits, labels, ignore_index: int = -100): + # Cast logits to f32 + # Flatten logits + return F.cross_entropy(logits.to(torch.float32).view(-1, logits.shape[-1]), labels.to(torch.long).view(-1), ignore_index=ignore_index, reduction="none").view(labels.shape) + + +class ACTLossHead(nn.Module): + def __init__(self, model: nn.Module, loss_type: str): + super().__init__() + self.model = model + self.loss_fn = globals()[loss_type] + + def initial_carry(self, *args, **kwargs): + return self.model.initial_carry(*args, **kwargs) # type: ignore + + def forward( + self, + return_keys: Sequence[str], + # Model args + **model_kwargs, + ) -> Tuple[Any, torch.Tensor, Dict[str, torch.Tensor], Optional[Dict[str, torch.Tensor]], torch.Tensor]: + # Model logits + # B x SeqLen x D + new_carry, outputs = self.model(**model_kwargs) + labels = new_carry.current_data["labels"] + + # Correctness + with torch.no_grad(): + mask = labels != IGNORE_LABEL_ID + loss_counts = mask.sum(-1) + loss_divisor = loss_counts.clamp_min(1).unsqueeze(-1) # Avoid NaNs in division + + is_correct = mask & (torch.argmax(outputs["logits"], dim=-1) == labels) + seq_is_correct = is_correct.sum(-1) == loss_counts + + # Metrics (halted) + valid_metrics = new_carry.halted & (loss_counts > 0) + metrics = { + "count": valid_metrics.sum(), + + "accuracy": torch.where(valid_metrics, (is_correct.to(torch.float32) / loss_divisor).sum(-1), 0).sum(), + "exact_accuracy": (valid_metrics & seq_is_correct).sum(), + + "q_halt_accuracy": (valid_metrics & ((outputs["q_halt_logits"] >= 0) == seq_is_correct)).sum(), + "steps": torch.where(valid_metrics, new_carry.steps, 0).sum(), + } + + # Losses + # FIXME: Assuming the batch is always full + lm_loss = (self.loss_fn(outputs["logits"], labels, ignore_index=IGNORE_LABEL_ID) / loss_divisor).sum() + q_halt_loss = F.binary_cross_entropy_with_logits(outputs["q_halt_logits"], seq_is_correct.to(outputs["q_halt_logits"].dtype), reduction="sum") + + metrics.update({ + "lm_loss": lm_loss.detach(), + "q_halt_loss": q_halt_loss.detach(), + }) + + # Q continue (bootstrapping target loss) + q_continue_loss = 0 + if "target_q_continue" in outputs: + q_continue_loss = F.binary_cross_entropy_with_logits(outputs["q_continue_logits"], outputs["target_q_continue"], reduction="sum") + + metrics["q_continue_loss"] = q_continue_loss.detach() + + # Filter outputs for return + detached_outputs = {k: outputs[k].detach() for k in return_keys if k in outputs} + + return new_carry, lm_loss + 0.5 * (q_halt_loss + q_continue_loss), metrics, detached_outputs, new_carry.halted.all() diff --git a/srm/models/sparse_embedding.py b/srm/models/sparse_embedding.py new file mode 100644 index 0000000..c701524 --- /dev/null +++ b/srm/models/sparse_embedding.py @@ -0,0 +1,132 @@ +from typing import Union + +import torch +from torch import nn +import torch.distributed as dist +from torch.optim.optimizer import Optimizer, ParamsT + +from models.common import trunc_normal_init_ + + +class CastedSparseEmbedding(nn.Module): + def __init__(self, num_embeddings: int, embedding_dim: int, batch_size: int, init_std: float, cast_to: torch.dtype): + super().__init__() + self.cast_to = cast_to + + # Real Weights + # Truncated LeCun normal init + self.weights = nn.Buffer( + trunc_normal_init_(torch.empty((num_embeddings, embedding_dim)), std=init_std), persistent=True + ) + + # Local weights and IDs + # Local embeddings, with gradient, not persistent + self.local_weights = nn.Buffer(torch.zeros(batch_size, embedding_dim, requires_grad=True), persistent=False) + # Local embedding IDs, not persistent + self.local_ids = nn.Buffer(torch.zeros(batch_size, dtype=torch.int32), persistent=False) + + def forward(self, inputs: torch.Tensor) -> torch.Tensor: + if not self.training: + # Test mode, no gradient + return self.weights[inputs].to(self.cast_to) + + # Training mode, fill puzzle embedding from weights + with torch.no_grad(): + self.local_weights.copy_(self.weights[inputs]) + self.local_ids.copy_(inputs) + + return self.local_weights.to(self.cast_to) + + +class CastedSparseEmbeddingSignSGD_Distributed(Optimizer): + def __init__( + self, + params: ParamsT, + + world_size: int, + lr: Union[float, torch.Tensor] = 1e-3, + weight_decay: float = 1e-2, + ): + if not 0.0 <= lr: + raise ValueError(f"Invalid learning rate: {lr}") + if not 0.0 <= weight_decay: + raise ValueError(f"Invalid weight_decay value: {weight_decay}") + + defaults = dict( + lr=lr, + weight_decay=weight_decay, + world_size=world_size + ) + super().__init__(params, defaults) + + @torch.no_grad + def step(self, closure=None): # type: ignore + for group in self.param_groups: + # Find the sparse embedding weights + local_weights_grad = None + local_ids = None + weights = None + + assert len(group["params"]) == 3 + for p in group["params"]: + if p.requires_grad: + local_weights_grad = p.grad + elif p.ndim == 1: + local_ids = p + elif p.ndim == 2: + weights = p + else: + assert False + + assert local_weights_grad is not None + assert local_ids is not None + assert weights is not None + + # Apply SignSGD + # Adam ≈ SignSGD if gradient is very sparse + _sparse_emb_signsgd_dist( + local_weights_grad, + local_ids, + weights, + + lr=group["lr"], + weight_decay=group["weight_decay"], + world_size=group["world_size"] + ) + + +def _sparse_emb_signsgd_dist( + local_weights_grad: torch.Tensor, + local_ids: torch.Tensor, + weights: torch.Tensor, + + lr: float, + weight_decay: float, + world_size: int +) -> None: + N, D = local_weights_grad.shape + + # All-gather + all_weights_grad = local_weights_grad + all_ids = local_ids + + if world_size > 1: + all_weights_grad = torch.empty((world_size * N, D), dtype=local_weights_grad.dtype, device=local_weights_grad.device) + all_ids = torch.empty(world_size * N, dtype=local_ids.dtype, device=local_ids.device) + + dist.all_gather_into_tensor(all_weights_grad, local_weights_grad) + dist.all_gather_into_tensor(all_ids, local_ids) + + # Unique + grad_ids, inv = all_ids.unique(return_inverse=True) + + grad = torch.zeros((grad_ids.shape[0], D), dtype=all_weights_grad.dtype, device=all_weights_grad.device) + grad.scatter_add_(0, inv.unsqueeze(-1).expand(-1, D), all_weights_grad) + + # SignSGD with decoupled weight decay + p = weights[grad_ids] + + p.mul_(1.0 - lr * weight_decay).add_(torch.sign(grad), alpha=-lr) + + # Write updated slices back + weights[grad_ids] = p diff --git a/srm/models/srm/__init__.py b/srm/models/srm/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/srm/models/srm/__init__.py diff --git a/srm/models/srm/hrm_orth_v1.py b/srm/models/srm/hrm_orth_v1.py new file mode 100644 index 0000000..65656df --- /dev/null +++ b/srm/models/srm/hrm_orth_v1.py @@ -0,0 +1,376 @@ +"""HRM-Orth v1 — orthogonal patch of HRM per codex round 2 recommendation. + +CORE IDEA (codex Q6 pivot, after pure-orthogonal retract Q1): +Keep HRM's H_level/L_level/ACT structure, just patch the inner Block: + - Attention → cosine-normalized attention (≈ Lipschitz-bounded) + - SwiGLU MLP → CayleyOrth linear + MaxMin + CayleyOrth linear + - rms_norm + add → weighted residual: h_new = (1-σ(w)) · h + σ(w) · f(h) + - "Weak orthogonality": diag(s) scaling with most s≈1, some s∈[0.90, 0.97] for compression + +Per codex Q5 decomp: target +5~+7pp over SRM v1 (0.39 → 0.43-0.46). +Per codex Q3: Cayley used (we have it from srm_aol_v1); Householder would be faster but more impl. +""" +from typing import Tuple, List, Dict, Optional +from dataclasses import dataclass +import math + +import torch +import torch.nn.functional as F +from torch import nn +from pydantic import BaseModel + +from models.common import trunc_normal_init_ +from models.layers import rms_norm, SwiGLU, Attention, RotaryEmbedding, CosSin, CastedEmbedding, CastedLinear +from models.sparse_embedding import CastedSparseEmbedding +from models.srm.srm_aol_v1 import CayleyOrthogonal + + +def maxmin(x: torch.Tensor, group: int = 2) -> torch.Tensor: + """1-Lipschitz norm-preserving activation (Anil et al. 2019 GroupSort). + + Pairs adjacent dims; outputs (min, max) per pair. Permutation a.e. → ||∇|| = 1. + Strictly better than ReLU under norm constraints (no rank-kill). + """ + *prefix, d = x.shape + if d % group != 0: + pad = group - (d % group) + x = F.pad(x, (0, pad)) + d = d + pad + xg = x.reshape(*prefix, d // group, group) + sorted_vals, _ = xg.sort(dim=-1) + return sorted_vals.reshape(*prefix, d) + + +def cosine_attention(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, + tau: float = 8.0) -> torch.Tensor: + """Cosine-normalized softmax attention. Approximately Lipschitz-bounded + (exact bound depends on tau and value norms — see LipsFormer Qi 2023).""" + q = F.normalize(q, dim=-1) + k = F.normalize(k, dim=-1) + attn = (q @ k.transpose(-2, -1)) * tau + attn = attn.softmax(dim=-1) + return attn @ v + + +class OrthLinear(nn.Module): + """Orthogonal linear layer via Cayley. Allows optional row-scaling diag(s) + where s_i ∈ [s_min, 1] to introduce 'weak orthogonality' (codex Q1 fix). + + If s_min < 1, the operator is contractive in some directions: + Lip = max(s) ≤ 1, det = prod(s) ≤ 1 (weak contraction in compressing modes) + """ + def __init__(self, dim: int, s_min: float = 0.85, learn_scale: bool = True, + init_std_scale: float = 5.0): + super().__init__() + self.Q = CayleyOrthogonal(dim) + # Bump init A by init_std_scale to push Cayley away from identity + with torch.no_grad(): + self.Q.A.mul_(init_std_scale) + self.s_min = s_min + # diag scale: sigmoid -> [s_min, 1] + if learn_scale and s_min < 1.0: + self.log_s_raw = nn.Parameter(torch.zeros(dim)) # init sigmoid(0)=0.5 → scale=(s_min+1)/2 + else: + self.register_buffer("log_s_raw", torch.zeros(dim)) + self.learn_scale = learn_scale + + def scale_diag(self) -> torch.Tensor: + if self.s_min >= 1.0 or not self.learn_scale: + return torch.ones_like(self.log_s_raw) + # Affine map sigmoid → [s_min, 1] + return self.s_min + (1.0 - self.s_min) * torch.sigmoid(self.log_s_raw) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + Q = self.Q() # (d, d) orthogonal + s = self.scale_diag().to(Q.dtype) # (d,) in [s_min, 1] + Qs = Q * s.unsqueeze(0) # rescale columns + return F.linear(x, Qs) + + +@dataclass +class HierarchicalReasoningModel_ACTV1InnerCarry: + z_H: torch.Tensor + z_L: torch.Tensor + + +@dataclass +class HierarchicalReasoningModel_ACTV1Carry: + inner_carry: HierarchicalReasoningModel_ACTV1InnerCarry + + steps: torch.Tensor + halted: torch.Tensor + + current_data: Dict[str, torch.Tensor] + + +class HierarchicalReasoningModel_ACTV1Config(BaseModel): + batch_size: int + seq_len: int + puzzle_emb_ndim: int = 0 + num_puzzle_identifiers: int + vocab_size: int + + H_cycles: int + L_cycles: int + + H_layers: int + L_layers: int + + # Transformer config + hidden_size: int + expansion: float + num_heads: int + pos_encodings: str + + rms_norm_eps: float = 1e-5 + rope_theta: float = 10000.0 + + # Halting Q-learning config + halt_max_steps: int + halt_exploration_prob: float + + forward_dtype: str = "bfloat16" + + +class HierarchicalReasoningModel_ACTV1Block(nn.Module): + """Orthogonal-patched HRM Block. + + Replaces (attn + SwiGLU + rms_norm) with (cosine attn + Orth-MLP + weighted residual). + The original class name preserved so the ReasoningModule wrapper is unchanged. + """ + def __init__(self, config: HierarchicalReasoningModel_ACTV1Config) -> None: + super().__init__() + d = config.hidden_size + s_min = getattr(config, "orth_s_min", 0.85) # v2: 0.95 → 0.85 for real contraction + cosine_tau = getattr(config, "cosine_attn_tau", 1.0) # v2: 8 → 1 for diverse softmax at init + init_std_scale = getattr(config, "orth_init_std_scale", 5.0) + + # Lipschitz-bounded cosine attention: orthogonal Q/K/V/O projections + self.q_proj = OrthLinear(d, s_min=1.0, learn_scale=False, init_std_scale=init_std_scale) + self.k_proj = OrthLinear(d, s_min=1.0, learn_scale=False, init_std_scale=init_std_scale) + self.v_proj = OrthLinear(d, s_min=s_min, learn_scale=True, init_std_scale=init_std_scale) + self.o_proj = OrthLinear(d, s_min=s_min, learn_scale=True, init_std_scale=init_std_scale) + self.cosine_tau = cosine_tau + + # Orth-MLP: OrthLinear -> MaxMin -> OrthLinear (no expansion; uses original d) + self.mlp_in = OrthLinear(d, s_min=s_min, learn_scale=True, init_std_scale=init_std_scale) + self.mlp_out = OrthLinear(d, s_min=s_min, learn_scale=True, init_std_scale=init_std_scale) + + # Weighted residual gates — v2: init logit=+2 → sigmoid=0.88 so block dominates + self.w_attn_logit = nn.Parameter(torch.full((), 2.0)) + self.w_mlp_logit = nn.Parameter(torch.full((), 2.0)) + + def forward(self, cos_sin: CosSin, hidden_states: torch.Tensor) -> torch.Tensor: + # Cosine attention + q = self.q_proj(hidden_states) + k = self.k_proj(hidden_states) + v = self.v_proj(hidden_states) + attn_out = self.o_proj(cosine_attention(q, k, v, tau=self.cosine_tau)) + w_attn = torch.sigmoid(self.w_attn_logit) + hidden_states = (1.0 - w_attn) * hidden_states + w_attn * attn_out + + # Orth-MLP with MaxMin + mlp_out = self.mlp_out(maxmin(self.mlp_in(hidden_states), group=2)) + w_mlp = torch.sigmoid(self.w_mlp_logit) + hidden_states = (1.0 - w_mlp) * hidden_states + w_mlp * mlp_out + return hidden_states + + +class HierarchicalReasoningModel_ACTV1ReasoningModule(nn.Module): + def __init__(self, layers: List[HierarchicalReasoningModel_ACTV1Block]): + super().__init__() + + self.layers = torch.nn.ModuleList(layers) + + def forward(self, hidden_states: torch.Tensor, input_injection: torch.Tensor, **kwargs) -> torch.Tensor: + # Input injection (add) + hidden_states = hidden_states + input_injection + # Layers + for layer in self.layers: + hidden_states = layer(hidden_states=hidden_states, **kwargs) + + return hidden_states + + +class HierarchicalReasoningModel_ACTV1_Inner(nn.Module): + def __init__(self, config: HierarchicalReasoningModel_ACTV1Config) -> None: + super().__init__() + self.config = config + self.forward_dtype = getattr(torch, self.config.forward_dtype) + + # I/O + self.embed_scale = math.sqrt(self.config.hidden_size) + embed_init_std = 1.0 / self.embed_scale + + self.embed_tokens = CastedEmbedding(self.config.vocab_size, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype) + self.lm_head = CastedLinear(self.config.hidden_size, self.config.vocab_size, bias=False) + self.q_head = CastedLinear(self.config.hidden_size, 2, bias=True) + + self.puzzle_emb_len = -(self.config.puzzle_emb_ndim // -self.config.hidden_size) # ceil div + if self.config.puzzle_emb_ndim > 0: + # Zero init puzzle embeddings + self.puzzle_emb = CastedSparseEmbedding(self.config.num_puzzle_identifiers, self.config.puzzle_emb_ndim, + batch_size=self.config.batch_size, init_std=0, cast_to=self.forward_dtype) + + # LM Blocks + if self.config.pos_encodings == "rope": + self.rotary_emb = RotaryEmbedding(dim=self.config.hidden_size // self.config.num_heads, + max_position_embeddings=self.config.seq_len + self.puzzle_emb_len, + base=self.config.rope_theta) + elif self.config.pos_encodings == "learned": + self.embed_pos = CastedEmbedding(self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, init_std=embed_init_std, cast_to=self.forward_dtype) + else: + raise NotImplementedError() + + # Reasoning Layers + self.H_level = HierarchicalReasoningModel_ACTV1ReasoningModule(layers=[HierarchicalReasoningModel_ACTV1Block(self.config) for _i in range(self.config.H_layers)]) + self.L_level = HierarchicalReasoningModel_ACTV1ReasoningModule(layers=[HierarchicalReasoningModel_ACTV1Block(self.config) for _i in range(self.config.L_layers)]) + + # Initial states + self.H_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True) + self.L_init = nn.Buffer(trunc_normal_init_(torch.empty(self.config.hidden_size, dtype=self.forward_dtype), std=1), persistent=True) + + # Q head special init + # Init Q to (almost) zero for faster learning during bootstrapping + with torch.no_grad(): + self.q_head.weight.zero_() + self.q_head.bias.fill_(-5) # type: ignore + + def _input_embeddings(self, input: torch.Tensor, puzzle_identifiers: torch.Tensor): + # Token embedding + embedding = self.embed_tokens(input.to(torch.int32)) + + # Puzzle embeddings + if self.config.puzzle_emb_ndim > 0: + puzzle_embedding = self.puzzle_emb(puzzle_identifiers) + + pad_count = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1] + if pad_count > 0: + puzzle_embedding = F.pad(puzzle_embedding, (0, pad_count)) + + embedding = torch.cat((puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size), embedding), dim=-2) + + # Position embeddings + if self.config.pos_encodings == "learned": + # scale by 1/sqrt(2) to maintain forward variance + embedding = 0.707106781 * (embedding + self.embed_pos.embedding_weight.to(self.forward_dtype)) + + # Scale + return self.embed_scale * embedding + + def empty_carry(self, batch_size: int): + return HierarchicalReasoningModel_ACTV1InnerCarry( + z_H=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype), + z_L=torch.empty(batch_size, self.config.seq_len + self.puzzle_emb_len, self.config.hidden_size, dtype=self.forward_dtype), + ) + + def reset_carry(self, reset_flag: torch.Tensor, carry: HierarchicalReasoningModel_ACTV1InnerCarry): + return HierarchicalReasoningModel_ACTV1InnerCarry( + z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H), + z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L), + ) + + def forward(self, carry: HierarchicalReasoningModel_ACTV1InnerCarry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + seq_info = dict( + cos_sin=self.rotary_emb() if hasattr(self, "rotary_emb") else None, + ) + + # Input encoding + input_embeddings = self._input_embeddings(batch["inputs"], batch["puzzle_identifiers"]) + + # Forward iterations + with torch.no_grad(): + z_H, z_L = carry.z_H, carry.z_L + + for _H_step in range(self.config.H_cycles): + for _L_step in range(self.config.L_cycles): + if not ((_H_step == self.config.H_cycles - 1) and (_L_step == self.config.L_cycles - 1)): + z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info) + + if not (_H_step == self.config.H_cycles - 1): + z_H = self.H_level(z_H, z_L, **seq_info) + + assert not z_H.requires_grad and not z_L.requires_grad + + # 1-step grad + z_L = self.L_level(z_L, z_H + input_embeddings, **seq_info) + z_H = self.H_level(z_H, z_L, **seq_info) + + # LM Outputs + new_carry = HierarchicalReasoningModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) # New carry no grad + output = self.lm_head(z_H)[:, self.puzzle_emb_len:] + + # Q head + q_logits = self.q_head(z_H[:, 0]).to(torch.float32) + + return new_carry, output, (q_logits[..., 0], q_logits[..., 1]) + + +class HierarchicalReasoningModel_ACTV1(nn.Module): + """ACT wrapper.""" + + def __init__(self, config_dict: dict): + super().__init__() + self.config = HierarchicalReasoningModel_ACTV1Config(**config_dict) + self.inner = HierarchicalReasoningModel_ACTV1_Inner(self.config) + + @property + def puzzle_emb(self): + return self.inner.puzzle_emb + + def initial_carry(self, batch: Dict[str, torch.Tensor]): + batch_size = batch["inputs"].shape[0] + + return HierarchicalReasoningModel_ACTV1Carry( + inner_carry=self.inner.empty_carry(batch_size), # Empty is expected, it will be reseted in first pass as all sequences are halted. + + steps=torch.zeros((batch_size, ), dtype=torch.int32), + halted=torch.ones((batch_size, ), dtype=torch.bool), # Default to halted + + current_data={k: torch.empty_like(v) for k, v in batch.items()} + ) + + def forward(self, carry: HierarchicalReasoningModel_ACTV1Carry, batch: Dict[str, torch.Tensor]) -> Tuple[HierarchicalReasoningModel_ACTV1Carry, Dict[str, torch.Tensor]]: + # Update data, carry (removing halted sequences) + new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry) + + new_steps = torch.where(carry.halted, 0, carry.steps) + + new_current_data = {k: torch.where(carry.halted.view((-1, ) + (1, ) * (batch[k].ndim - 1)), batch[k], v) for k, v in carry.current_data.items()} + + # Forward inner model + new_inner_carry, logits, (q_halt_logits, q_continue_logits) = self.inner(new_inner_carry, new_current_data) + + outputs = { + "logits": logits, + "q_halt_logits": q_halt_logits, + "q_continue_logits": q_continue_logits + } + + with torch.no_grad(): + # Step + new_steps = new_steps + 1 + is_last_step = new_steps >= self.config.halt_max_steps + + halted = is_last_step + + # if training, and ACT is enabled + if self.training and (self.config.halt_max_steps > 1): + # Halt signal + # NOTE: During evaluation, always use max steps, this is to guarantee the same halting steps inside a batch for batching purposes + halted = halted | (q_halt_logits > q_continue_logits) + + # Exploration + min_halt_steps = (torch.rand_like(q_halt_logits) < self.config.halt_exploration_prob) * torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1) + + halted = halted & (new_steps >= min_halt_steps) + + # Compute target Q + # NOTE: No replay buffer and target networks for computing target Q-value. + # As batch_size is large, there're many parallel envs. + # Similar concept as PQN https://arxiv.org/abs/2407.04811 + next_q_halt_logits, next_q_continue_logits = self.inner(new_inner_carry, new_current_data)[-1] + + outputs["target_q_continue"] = torch.sigmoid(torch.where(is_last_step, next_q_halt_logits, torch.maximum(next_q_halt_logits, next_q_continue_logits))) + + return HierarchicalReasoningModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs diff --git a/srm/models/srm/srm_aol_v1.py b/srm/models/srm/srm_aol_v1.py new file mode 100644 index 0000000..c4e2719 --- /dev/null +++ b/srm/models/srm/srm_aol_v1.py @@ -0,0 +1,494 @@ +"""SRM-Joint-AOL v1 — Stable Recursive Model (forked from hrm_act_v1.py). + +Replaces HRM's separate H_level / L_level transformer stacks with ONE joint +operator T on state z = (h, l) that is provably contractive under weighted +P-norm ||z||²_P = ||h||² + η||l||² with Lipschitz constant ≤ κ ∈ (0.85, 0.95). + +Key replacement vs HRM: +- HierarchicalReasoningModel_ACTV1Block (attn + SwiGLU) + → StableRecursionModel_ACTV1Block (joint SRM step on (h, l)) +- ReasoningModule wraps n_iters joint updates instead of separate H/L cycles. + +Lipschitz analysis (per step, in P-norm): + Lip_P(T) ≤ (1-α) + α · κ < 1 + ⇒ joint top-1 Lyapunov per micro-step: λ_1 ≤ log((1-α) + α·κ) < 0 + +ARCHITECTURE (one joint step): + z = concat(h + b_in_h(x), √η · (l + b_in_l(x))) # join with input bias + ψ = AOL_Block(z) # Lip_P(ψ) ≤ 1 + ψ_h, ψ_l_scaled = split(ψ); ψ_l = ψ_l_scaled / √η + Az_h = a_HH·ψ_h + a_HL·(U_HL·ψ_l) # gain row sum ≤ κ + Az_l = a_LH·(U_LH·ψ_h) + a_LL·ψ_l + h_new = (1-α)·h + α·Az_h + b_out_h(x) + l_new = (1-α)·l + α·Az_l + b_out_l(x) + +REUSED FROM HRM: +- ACT framework (q_head, halt logic) +- CastedEmbedding/CastedLinear (bf16-safe linears) +- CastedSparseEmbedding (puzzle_emb) +- 1-step grad / DEQ-style truncation +""" +from typing import Tuple, Dict +from dataclasses import dataclass +import math + +import torch +import torch.nn.functional as F +from torch import nn +from pydantic import BaseModel + +from models.common import trunc_normal_init_ +from models.layers import CastedEmbedding, CastedLinear +from models.sparse_embedding import CastedSparseEmbedding + + +# ============================================================================= +# Approximately 1-Lipschitz primitives +# Normalization (AOL) and orthogonalization (Cayley) are computed in float32, +# then cast to forward dtype (bf16 by default). The bound is *exact in fp32* +# but only approximate after cast — bf16 rounding introduces a small error +# that accumulates over n_aol_layers matmuls. Empirically the margin to the +# theoretical κ-bound is large (~5×), so this is fine in practice, but the +# guarantee is not strict. For applications where strictness matters, run +# the bounded operators in float32. +# ============================================================================= + +class AOLLinear(nn.Module): + """≤1-Lipschitz linear layer via AOL (Prach & Lampert 2022) rescaling. + + Given W ∈ R^(out × in), let A = W^T W (symmetric PSD). + Define D_jj = 1 / √(Σ_i |A_ij| + eps); set W̃ = W · diag(D). + Then ||W̃ x||_2 ≤ ||x||_2 in float32 (Prach & Lampert Theorem 1). + Bound is approximate (not exact) under bf16 due to rounding in W·diag(D) + and the subsequent matmul. Bias is unconstrained (shift only, doesn't + affect Lipschitz w.r.t. input). + """ + def __init__(self, in_dim: int, out_dim: int, bias: bool = True, + cast_to: torch.dtype = torch.bfloat16, eps: float = 1e-6): + super().__init__() + std = 1.0 / math.sqrt(in_dim) + self.W = nn.Parameter(torch.randn(out_dim, in_dim) * std) + self.b = nn.Parameter(torch.zeros(out_dim)) if bias else None + self.cast_to = cast_to + self.eps = eps + + def normalized_weight(self) -> torch.Tensor: + W32 = self.W.float() + WTW = W32.t() @ W32 + col_abs_sum = WTW.abs().sum(dim=0) + scale = torch.rsqrt(col_abs_sum + self.eps) + return (W32 * scale.unsqueeze(0)).to(self.cast_to) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + W = self.normalized_weight() + out = F.linear(x, W) + if self.b is not None: + out = out + self.b.to(out.dtype) + return out + + +class AOLBlock(nn.Module): + """Stack of AOLLinear with 1-Lipschitz activation (ReLU) between layers. + + Composition of 1-Lipschitz maps is 1-Lipschitz. SiLU/GELU NOT allowed + (max derivative > 1 would break the bound). + """ + def __init__(self, dim: int, n_layers: int = 2, cast_to: torch.dtype = torch.bfloat16): + super().__init__() + assert n_layers >= 1 + self.layers = nn.ModuleList([ + AOLLinear(dim, dim, bias=True, cast_to=cast_to) for _ in range(n_layers) + ]) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + for i, layer in enumerate(self.layers): + x = layer(x) + if i < len(self.layers) - 1: + x = F.relu(x) + return x + + +class CayleyOrthogonal(nn.Module): + """Approximately orthogonal Q ∈ R^(d × d) via Cayley transform. + + Q = (I + S)^{-1}(I - S) where S = (A - A^T)/2 is skew-symmetric. + Since (I+S) and (I-S) commute (both polynomials in S), the form is also + Q = (I - S)(I + S)^{-1}. Q^T Q = I exactly in float32 — approximate + after cast to bf16. Solve done in float32 for numerical stability. + NOTE: torch.linalg.solve may not be fullgraph-compile friendly. Test + before enabling torch.compile / FSDP. + """ + def __init__(self, dim: int, cast_to: torch.dtype = torch.bfloat16): + super().__init__() + self.A = nn.Parameter(torch.randn(dim, dim) * (1.0 / math.sqrt(dim))) + self.dim = dim + self.cast_to = cast_to + self.register_buffer("I", torch.eye(dim), persistent=False) + + def forward(self) -> torch.Tensor: + A32 = self.A.float() + S = 0.5 * (A32 - A32.t()) + I = self.I.float() + Q = torch.linalg.solve(I + S, I - S) + return Q.to(self.cast_to) + + +class BlockGain(nn.Module): + """Block gain matrix A with row sums ≤ κ under weighted P-norm. + + H row entries (P-normalized): [a_HH, √η · a_HL], sum = κ + L row entries (P-normalized): [(1/√η) · a_LH, a_LL], sum = κ + Parameterized via softmax × κ ⇒ exact equality (saturation). + """ + def __init__(self, kappa: float = 0.9, eta: float = 1.0, init_diag: float = 3.0): + super().__init__() + self.kappa = kappa + self.eta = eta + # init_diag=3.0 → softmax([3, 0]) ≈ [0.953, 0.047] ⇒ ~5% cross-coupling at start + # (init_diag=1.0 was too weak — gave 27% cross-coupling; init_diag=3.0 truly minimal) + self.logits_H = nn.Parameter(torch.tensor([init_diag, 0.0])) + self.logits_L = nn.Parameter(torch.tensor([0.0, init_diag])) + + def forward(self) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + sqrt_eta = math.sqrt(self.eta) + gH = self.kappa * F.softmax(self.logits_H.float(), dim=0) + a_HH, a_HL_scaled = gH[0], gH[1] + a_HL = a_HL_scaled / sqrt_eta + gL = self.kappa * F.softmax(self.logits_L.float(), dim=0) + a_LH_scaled, a_LL = gL[0], gL[1] + a_LH = a_LH_scaled * sqrt_eta + return a_HH, a_HL, a_LH, a_LL + + +class AOLTokenMixer(nn.Module): + """1-Lipschitz mixing across token (seq) and channel dims via AOL. + + Pipeline for x of shape (B, seq, dim): + 1) Channel mix (AOL across `dim`) + 2) ReLU + 3) Token mix (AOL across `seq`, applied after transpose) + 4) ReLU + Composition of 1-Lipschitz maps ⇒ Lip ≤ 1. + """ + def __init__(self, seq_len: int, dim: int, n_layers: int = 1, + cast_to: torch.dtype = torch.bfloat16): + super().__init__() + self.channel_mix = AOLBlock(dim=dim, n_layers=n_layers, cast_to=cast_to) + self.token_mix = AOLBlock(dim=seq_len, n_layers=n_layers, cast_to=cast_to) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + y = self.channel_mix(x) + y = F.relu(y) + y = y.transpose(-2, -1) # (B, dim, seq) + y = self.token_mix(y) + y = y.transpose(-2, -1) # (B, seq, dim) + return y + + +# ============================================================================= +# Carry types and config +# ============================================================================= + +@dataclass +class StableRecursionModel_ACTV1InnerCarry: + z_H: torch.Tensor + z_L: torch.Tensor + + +@dataclass +class StableRecursionModel_ACTV1Carry: + inner_carry: StableRecursionModel_ACTV1InnerCarry + steps: torch.Tensor + halted: torch.Tensor + current_data: Dict[str, torch.Tensor] + + +class StableRecursionModel_ACTV1Config(BaseModel): + batch_size: int + seq_len: int + puzzle_emb_ndim: int = 0 + num_puzzle_identifiers: int + vocab_size: int + + # SRM-specific + n_iters: int = 12 # joint micro-steps per ACT step + n_aol_layers: int = 2 # depth of ψ AOL block + kappa: float = 0.9 + eta: float = 1.0 + alpha: float = 1.0 + + # Shared with HRM + hidden_size: int + halt_max_steps: int + halt_exploration_prob: float = 0.1 + forward_dtype: str = "bfloat16" + + +# ============================================================================= +# SRM joint step (replaces HRM's H/L transformer blocks) +# ============================================================================= + +class StableRecursionModel_ACTV1Block(nn.Module): + """One SRM joint step on (h, l). Per-step Lip_P ≤ (1-α) + α·κ < 1.""" + def __init__(self, config: StableRecursionModel_ACTV1Config, seq_full: int) -> None: + super().__init__() + self.config = config + self.hidden_size = config.hidden_size + self.kappa = config.kappa + self.eta = config.eta + self.alpha = config.alpha + cast = getattr(torch, config.forward_dtype) + + joint_dim = 2 * config.hidden_size + self.psi = AOLTokenMixer(seq_len=seq_full, dim=joint_dim, + n_layers=config.n_aol_layers, cast_to=cast) + self.gain = BlockGain(kappa=config.kappa, eta=config.eta) + self.U_HL = CayleyOrthogonal(config.hidden_size, cast_to=cast) + self.U_LH = CayleyOrthogonal(config.hidden_size, cast_to=cast) + + # Input biases — unconstrained (only affect Lip w.r.t. x, not w.r.t. z; + # x is fixed across recursion so doesn't affect Lyapunov) + self.bias_in_h = CastedLinear(config.hidden_size, config.hidden_size, bias=True) + self.bias_in_l = CastedLinear(config.hidden_size, config.hidden_size, bias=True) + self.bias_out_h = CastedLinear(config.hidden_size, config.hidden_size, bias=True) + self.bias_out_l = CastedLinear(config.hidden_size, config.hidden_size, bias=True) + + def forward(self, h: torch.Tensor, l: torch.Tensor, input_emb: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + sqrt_eta = math.sqrt(self.eta) + + # 1. Join with input bias + h_in = h + self.bias_in_h(input_emb) + l_in = l + self.bias_in_l(input_emb) + z = torch.cat([h_in, sqrt_eta * l_in], dim=-1) # (B, seq, 2h) + + # 2. 1-Lipschitz feature map ψ + psi = self.psi(z) + psi_h, psi_l_scaled = psi.chunk(2, dim=-1) + psi_l = psi_l_scaled / sqrt_eta + + # 3. Block-gain matrix A (κ-bounded row sums) + a_HH, a_HL, a_LH, a_LL = self.gain() + U_HL = self.U_HL() + U_LH = self.U_LH() + psi_l_mix = F.linear(psi_l, U_HL) # ≡ psi_l @ U_HL.T + psi_h_mix = F.linear(psi_h, U_LH) + Az_h = a_HH * psi_h + a_HL * psi_l_mix + Az_l = a_LH * psi_h_mix + a_LL * psi_l + + # 4. Damped update + output bias + h_new = (1.0 - self.alpha) * h + self.alpha * Az_h + self.bias_out_h(input_emb) + l_new = (1.0 - self.alpha) * l + self.alpha * Az_l + self.bias_out_l(input_emb) + return h_new, l_new + + +# ============================================================================= +# Inner model + ACT wrapper (matches HRM_ACTV1 interface) +# ============================================================================= + +class StableRecursionModel_ACTV1_Inner(nn.Module): + def __init__(self, config: StableRecursionModel_ACTV1Config) -> None: + super().__init__() + self.config = config + self.forward_dtype = getattr(torch, config.forward_dtype) + + self.embed_scale = math.sqrt(config.hidden_size) + embed_init_std = 1.0 / self.embed_scale + + self.embed_tokens = CastedEmbedding(config.vocab_size, config.hidden_size, + init_std=embed_init_std, cast_to=self.forward_dtype) + self.lm_head = CastedLinear(config.hidden_size, config.vocab_size, bias=False) + self.q_head = CastedLinear(config.hidden_size, 2, bias=True) + with torch.no_grad(): + self.q_head.weight.zero_() + self.q_head.bias.fill_(-5) + + self.puzzle_emb_len = -(config.puzzle_emb_ndim // -config.hidden_size) + if config.puzzle_emb_ndim > 0: + self.puzzle_emb = CastedSparseEmbedding( + config.num_puzzle_identifiers, config.puzzle_emb_ndim, + batch_size=config.batch_size, init_std=0, cast_to=self.forward_dtype, + ) + seq_full = config.seq_len + self.puzzle_emb_len + + # Single tied SRM block used n_iters times per ACT step + self.srm_block = StableRecursionModel_ACTV1Block(config, seq_full=seq_full) + + self.H_init = nn.Buffer( + trunc_normal_init_(torch.empty(config.hidden_size, dtype=self.forward_dtype), std=1), + persistent=True, + ) + self.L_init = nn.Buffer( + trunc_normal_init_(torch.empty(config.hidden_size, dtype=self.forward_dtype), std=1), + persistent=True, + ) + + def _input_embeddings(self, input_ids: torch.Tensor, puzzle_ids: torch.Tensor) -> torch.Tensor: + emb = self.embed_tokens(input_ids.to(torch.int32)) + if self.config.puzzle_emb_ndim > 0: + puzzle_embedding = self.puzzle_emb(puzzle_ids) + pad = self.puzzle_emb_len * self.config.hidden_size - puzzle_embedding.shape[-1] + if pad > 0: + puzzle_embedding = F.pad(puzzle_embedding, (0, pad)) + puzzle_embedding = puzzle_embedding.view(-1, self.puzzle_emb_len, self.config.hidden_size) + emb = torch.cat((puzzle_embedding, emb), dim=-2) + return self.embed_scale * emb + + def empty_carry(self, batch_size: int) -> StableRecursionModel_ACTV1InnerCarry: + seq_full = self.config.seq_len + self.puzzle_emb_len + return StableRecursionModel_ACTV1InnerCarry( + z_H=torch.empty(batch_size, seq_full, self.config.hidden_size, dtype=self.forward_dtype), + z_L=torch.empty(batch_size, seq_full, self.config.hidden_size, dtype=self.forward_dtype), + ) + + def reset_carry(self, reset_flag: torch.Tensor, + carry: StableRecursionModel_ACTV1InnerCarry) -> StableRecursionModel_ACTV1InnerCarry: + return StableRecursionModel_ACTV1InnerCarry( + z_H=torch.where(reset_flag.view(-1, 1, 1), self.H_init, carry.z_H), + z_L=torch.where(reset_flag.view(-1, 1, 1), self.L_init, carry.z_L), + ) + + def forward(self, carry: StableRecursionModel_ACTV1InnerCarry, + batch: Dict[str, torch.Tensor]) -> Tuple[StableRecursionModel_ACTV1InnerCarry, torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + input_emb = self._input_embeddings(batch["inputs"], batch["puzzle_identifiers"]) + + # n_iters - 1 no-grad iterations + 1 grad iteration (HRM-style DEQ truncation) + with torch.no_grad(): + z_H, z_L = carry.z_H, carry.z_L + for _ in range(self.config.n_iters - 1): + z_H, z_L = self.srm_block(z_H, z_L, input_emb) + assert not z_H.requires_grad and not z_L.requires_grad + + z_H, z_L = self.srm_block(z_H, z_L, input_emb) + + new_carry = StableRecursionModel_ACTV1InnerCarry(z_H=z_H.detach(), z_L=z_L.detach()) + output = self.lm_head(z_H)[:, self.puzzle_emb_len:] + q_logits = self.q_head(z_H[:, 0]).to(torch.float32) + return new_carry, output, (q_logits[..., 0], q_logits[..., 1]) + + +class StableRecursionModel_ACTV1(nn.Module): + """ACT wrapper — mirrors HierarchicalReasoningModel_ACTV1 1-to-1.""" + def __init__(self, config_dict: dict): + super().__init__() + self.config = StableRecursionModel_ACTV1Config(**config_dict) + self.inner = StableRecursionModel_ACTV1_Inner(self.config) + + @property + def puzzle_emb(self): + return self.inner.puzzle_emb + + def initial_carry(self, batch: Dict[str, torch.Tensor]) -> StableRecursionModel_ACTV1Carry: + B = batch["inputs"].shape[0] + return StableRecursionModel_ACTV1Carry( + inner_carry=self.inner.empty_carry(B), + steps=torch.zeros((B,), dtype=torch.int32), + halted=torch.ones((B,), dtype=torch.bool), + current_data={k: torch.empty_like(v) for k, v in batch.items()}, + ) + + def forward(self, carry: StableRecursionModel_ACTV1Carry, + batch: Dict[str, torch.Tensor]) -> Tuple[StableRecursionModel_ACTV1Carry, Dict[str, torch.Tensor]]: + new_inner_carry = self.inner.reset_carry(carry.halted, carry.inner_carry) + new_steps = torch.where(carry.halted, 0, carry.steps) + new_current_data = { + k: torch.where(carry.halted.view((-1,) + (1,) * (batch[k].ndim - 1)), batch[k], v) + for k, v in carry.current_data.items() + } + + new_inner_carry, logits, (q_halt, q_continue) = self.inner(new_inner_carry, new_current_data) + outputs = {"logits": logits, "q_halt_logits": q_halt, "q_continue_logits": q_continue} + + with torch.no_grad(): + new_steps = new_steps + 1 + is_last = new_steps >= self.config.halt_max_steps + halted = is_last + + if self.training and self.config.halt_max_steps > 1: + halted = halted | (q_halt > q_continue) + min_halt = (torch.rand_like(q_halt) < self.config.halt_exploration_prob) * \ + torch.randint_like(new_steps, low=2, high=self.config.halt_max_steps + 1) + halted = halted & (new_steps >= min_halt) + + next_q_halt, next_q_continue = self.inner(new_inner_carry, new_current_data)[-1] + outputs["target_q_continue"] = torch.sigmoid( + torch.where(is_last, next_q_halt, torch.maximum(next_q_halt, next_q_continue)) + ) + + return StableRecursionModel_ACTV1Carry(new_inner_carry, new_steps, halted, new_current_data), outputs + + +# ============================================================================= +# Empirical Lipschitz diagnostic +# ============================================================================= + +@torch.no_grad() +def measure_lipschitz_constant(inner: StableRecursionModel_ACTV1_Inner, + sample_batch: Dict[str, torch.Tensor], + n_probes: int = 64, eps: float = 1e-3) -> Dict[str, float]: + """Estimate Lip_P of srm_block via random perturbations. + + Returns ratio ||T(z+δ) - T(z)||_P / ||δ||_P. Should be ≤ (1-α) + α·κ. + """ + cfg = inner.config + B = sample_batch["inputs"].shape[0] + seq_full = cfg.seq_len + inner.puzzle_emb_len + h = inner.H_init.unsqueeze(0).expand(B, seq_full, cfg.hidden_size).to(inner.forward_dtype).clone() + l = inner.L_init.unsqueeze(0).expand(B, seq_full, cfg.hidden_size).to(inner.forward_dtype).clone() + input_emb = inner._input_embeddings(sample_batch["inputs"], sample_batch["puzzle_identifiers"]) + h_new, l_new = inner.srm_block(h, l, input_emb) + + ratios = [] + for _ in range(n_probes): + dh = torch.randn_like(h) * eps + dl = torch.randn_like(l) * eps + h_p, l_p = inner.srm_block(h + dh, l + dl, input_emb) + d_in_h = dh.float().flatten(1).pow(2).sum(1) + d_in_l = dl.float().flatten(1).pow(2).sum(1) + d_in_P = (d_in_h + cfg.eta * d_in_l).sqrt() + d_out_h = (h_p - h_new).float().flatten(1).pow(2).sum(1) + d_out_l = (l_p - l_new).float().flatten(1).pow(2).sum(1) + d_out_P = (d_out_h + cfg.eta * d_out_l).sqrt() + ratios.append((d_out_P / d_in_P.clamp_min(1e-12)).cpu()) + R = torch.cat(ratios) + bound = (1 - cfg.alpha) + cfg.alpha * cfg.kappa + return { + "lip_emp_mean": float(R.mean()), + "lip_emp_max": float(R.max()), + "lip_emp_99p": float(R.quantile(0.99)), + "lip_theoretical_bound": float(bound), + "passes_bound": bool(R.max() <= bound * 1.05), + } + + +if __name__ == "__main__": + cfg = dict( + batch_size=4, seq_len=81, vocab_size=11, + num_puzzle_identifiers=1, puzzle_emb_ndim=512, + hidden_size=256, n_iters=6, n_aol_layers=2, + kappa=0.9, eta=1.0, alpha=1.0, + halt_max_steps=4, halt_exploration_prob=0.1, + forward_dtype="bfloat16", + ) + model = StableRecursionModel_ACTV1(cfg).cuda() + print(f"params={sum(p.numel() for p in model.parameters()):,}") + + batch = { + "inputs": torch.randint(0, 11, (4, 81), dtype=torch.int32).cuda(), + "labels": torch.randint(0, 11, (4, 81), dtype=torch.int32).cuda(), + "puzzle_identifiers": torch.zeros(4, dtype=torch.int32).cuda(), + } + carry = model.initial_carry(batch) + carry.inner_carry.z_H = carry.inner_carry.z_H.cuda() + carry.inner_carry.z_L = carry.inner_carry.z_L.cuda() + carry.steps = carry.steps.cuda() + carry.halted = carry.halted.cuda() + for k in carry.current_data: + carry.current_data[k] = batch[k] + + model.eval() + new_carry, out = model(carry, batch) + print(f"forward OK | logits={out['logits'].shape}") + + lip = measure_lipschitz_constant(model.inner, batch, n_probes=32) + print(f"Lipschitz check: emp_max={lip['lip_emp_max']:.4f} bound={lip['lip_theoretical_bound']:.4f} " + f"passes={lip['passes_bound']} emp_mean={lip['lip_emp_mean']:.4f}") diff --git a/srm/pretrain.py b/srm/pretrain.py new file mode 100644 index 0000000..245cb5c --- /dev/null +++ b/srm/pretrain.py @@ -0,0 +1,453 @@ +from typing import Optional, Any, Sequence, List +from dataclasses import dataclass +import os +import math +import yaml +import shutil + +import torch +import torch.distributed as dist +from torch import nn +from torch.utils.data import DataLoader + +import tqdm +import wandb +import coolname +import hydra +import pydantic +from omegaconf import DictConfig +from adam_atan2 import AdamATan2 + +from puzzle_dataset import PuzzleDataset, PuzzleDatasetConfig, PuzzleDatasetMetadata +from utils.functions import load_model_class, get_model_source_path +from models.sparse_embedding import CastedSparseEmbeddingSignSGD_Distributed + + +class LossConfig(pydantic.BaseModel): + model_config = pydantic.ConfigDict(extra='allow') + + name: str + + +class ArchConfig(pydantic.BaseModel): + model_config = pydantic.ConfigDict(extra='allow') + + name: str + loss: LossConfig + + +class PretrainConfig(pydantic.BaseModel): + # Config + arch: ArchConfig + # Data + data_path: str + + # Hyperparams + global_batch_size: int + epochs: int + + lr: float + lr_min_ratio: float + lr_warmup_steps: int + + weight_decay: float + beta1: float + beta2: float + + # Puzzle embedding + puzzle_emb_lr: float + puzzle_emb_weight_decay: float + + # Names + project_name: Optional[str] = None + run_name: Optional[str] = None + checkpoint_path: Optional[str] = None + + # Extras + seed: int = 0 + checkpoint_every_eval: bool = False + eval_interval: Optional[int] = None + eval_save_outputs: List[str] = [] + + +@dataclass +class TrainState: + model: nn.Module + optimizers: Sequence[torch.optim.Optimizer] + optimizer_lrs: Sequence[float] + carry: Any + + step: int + total_steps: int + + +def create_dataloader(config: PretrainConfig, split: str, rank: int, world_size: int, **kwargs): + dataset = PuzzleDataset(PuzzleDatasetConfig( + seed=config.seed, + + dataset_path=config.data_path, + + rank=rank, + num_replicas=world_size, + + **kwargs + ), split=split) + dataloader = DataLoader( + dataset, + batch_size=None, + + num_workers=1, + prefetch_factor=8, + + pin_memory=True, + persistent_workers=True + ) + return dataloader, dataset.metadata + + +def create_model(config: PretrainConfig, train_metadata: PuzzleDatasetMetadata, world_size: int): + model_cfg = dict( + **config.arch.__pydantic_extra__, # type: ignore + + batch_size=config.global_batch_size // world_size, + + vocab_size=train_metadata.vocab_size, + seq_len=train_metadata.seq_len, + num_puzzle_identifiers=train_metadata.num_puzzle_identifiers, + causal=False # Non-autoregressive + ) + + # Instantiate model with loss head + model_cls = load_model_class(config.arch.name) + loss_head_cls = load_model_class(config.arch.loss.name) + + with torch.device("cuda"): + model: nn.Module = model_cls(model_cfg) + model = loss_head_cls(model, **config.arch.loss.__pydantic_extra__) # type: ignore + if "DISABLE_COMPILE" not in os.environ: + model = torch.compile(model, dynamic=False) # type: ignore + + # Broadcast parameters from rank 0 + if world_size > 1: + with torch.no_grad(): + for param in list(model.parameters()) + list(model.buffers()): + dist.broadcast(param, src=0) + + # Optimizers and lr + optimizers = [ + CastedSparseEmbeddingSignSGD_Distributed( + model.model.puzzle_emb.buffers(), # type: ignore + + lr=0, # Needs to be set by scheduler + weight_decay=config.puzzle_emb_weight_decay, + + world_size=world_size + ), + AdamATan2( + model.parameters(), + + lr=0, # Needs to be set by scheduler + weight_decay=config.weight_decay, + betas=(config.beta1, config.beta2) + ) + ] + optimizer_lrs = [ + config.puzzle_emb_lr, + config.lr + ] + + return model, optimizers, optimizer_lrs + + +def cosine_schedule_with_warmup_lr_lambda( + current_step: int, *, base_lr: float, num_warmup_steps: int, num_training_steps: int, min_ratio: float = 0.0, num_cycles: float = 0.5 +): + if current_step < num_warmup_steps: + return base_lr * float(current_step) / float(max(1, num_warmup_steps)) + + progress = float(current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps)) + return base_lr * (min_ratio + max(0.0, (1 - min_ratio) * 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress)))) + + +def init_train_state(config: PretrainConfig, train_metadata: PuzzleDatasetMetadata, world_size: int): + # Estimated total training steps + total_steps = int(config.epochs * train_metadata.total_groups * train_metadata.mean_puzzle_examples / config.global_batch_size) + + # Model + model, optimizers, optimizer_lrs = create_model(config, train_metadata, world_size=world_size) + + return TrainState( + step=0, + total_steps=total_steps, + + model=model, + optimizers=optimizers, + optimizer_lrs=optimizer_lrs, + carry=None + ) + + +def save_train_state(config: PretrainConfig, train_state: TrainState): + # FIXME: Only saved model. + if config.checkpoint_path is None: + return + + os.makedirs(config.checkpoint_path, exist_ok=True) + torch.save(train_state.model.state_dict(), os.path.join(config.checkpoint_path, f"step_{train_state.step}")) + + +def compute_lr(base_lr: float, config: PretrainConfig, train_state: TrainState): + return cosine_schedule_with_warmup_lr_lambda( + current_step=train_state.step, + base_lr=base_lr, + num_warmup_steps=round(config.lr_warmup_steps), + num_training_steps=train_state.total_steps, + min_ratio=config.lr_min_ratio + ) + + +def train_batch(config: PretrainConfig, train_state: TrainState, batch: Any, global_batch_size: int, rank: int, world_size: int): + train_state.step += 1 + if train_state.step > train_state.total_steps: # At most train_total_steps + return + + # To device + batch = {k: v.cuda() for k, v in batch.items()} + + # Init carry if it is None + if train_state.carry is None: + with torch.device("cuda"): + train_state.carry = train_state.model.initial_carry(batch) # type: ignore + + # Forward + train_state.carry, loss, metrics, _, _ = train_state.model(carry=train_state.carry, batch=batch, return_keys=[]) + + ((1 / global_batch_size) * loss).backward() + + # Allreduce + if world_size > 1: + for param in train_state.model.parameters(): + if param.grad is not None: + dist.all_reduce(param.grad) + + # Apply optimizer + lr_this_step = None + for optim, base_lr in zip(train_state.optimizers, train_state.optimizer_lrs): + lr_this_step = compute_lr(base_lr, config, train_state) + + for param_group in optim.param_groups: + param_group['lr'] = lr_this_step + + optim.step() + optim.zero_grad() + + # Reduce metrics + if len(metrics): + assert not any(v.requires_grad for v in metrics.values()) + + metric_keys = list(sorted(metrics.keys())) # Sort keys to guarantee all processes use the same order. + # Reduce and reconstruct + metric_values = torch.stack([metrics[k] for k in metric_keys]) + if world_size > 1: + dist.reduce(metric_values, dst=0) + + if rank == 0: + metric_values = metric_values.cpu().numpy() + reduced_metrics = {k: metric_values[i] for i, k in enumerate(metric_keys)} + + # Postprocess + count = max(reduced_metrics["count"], 1) # Avoid NaNs + reduced_metrics = {f"train/{k}": v / (global_batch_size if k.endswith("loss") else count) for k, v in reduced_metrics.items()} + + reduced_metrics["train/lr"] = lr_this_step + return reduced_metrics + + +def evaluate(config: PretrainConfig, train_state: TrainState, eval_loader: torch.utils.data.DataLoader, eval_metadata: PuzzleDatasetMetadata, rank: int, world_size: int): + with torch.inference_mode(): + set_ids = {k: idx for idx, k in enumerate(eval_metadata.sets)} + + all_preds = {} + + metric_keys = [] + metric_values = None + metric_global_batch_size = [0 for _ in range(len(set_ids))] + + carry = None + for set_name, batch, global_batch_size in eval_loader: + # To device + batch = {k: v.cuda() for k, v in batch.items()} + with torch.device("cuda"): + carry = train_state.model.initial_carry(batch) # type: ignore + + # Forward + while True: + carry, _, metrics, preds, all_finish = train_state.model(carry=carry, batch=batch, return_keys=config.eval_save_outputs) + + if all_finish: + break + + for collection in (batch, preds): + for k, v in collection.items(): + if k in config.eval_save_outputs: + all_preds.setdefault(k, []) + all_preds[k].append(v.cpu()) # Move to CPU for saving GPU memory + + del carry, preds, batch, all_finish + + # Aggregate + set_id = set_ids[set_name] + + if metric_values is None: + metric_keys = list(sorted(metrics.keys())) # Sort keys to guarantee all processes use the same order. + metric_values = torch.zeros((len(set_ids), len(metrics.values())), dtype=torch.float32, device="cuda") + + metric_values[set_id] += torch.stack([metrics[k] for k in metric_keys]) + metric_global_batch_size[set_id] += global_batch_size + + if len(all_preds) and config.checkpoint_path is not None: + all_preds = {k: torch.cat(v, dim=0) for k, v in all_preds.items()} + + os.makedirs(config.checkpoint_path, exist_ok=True) + torch.save(all_preds, os.path.join(config.checkpoint_path, f"step_{train_state.step}_all_preds.{rank}")) + + # Logging + # Reduce to rank 0 + if metric_values is not None: + if world_size > 1: + dist.reduce(metric_values, dst=0) + + if rank == 0: + reduced_metrics = metric_values.cpu().numpy() + reduced_metrics = {set_name: {metric_name: reduced_metrics[set_id, metric_id] for metric_id, metric_name in enumerate(metric_keys)} + for set_id, set_name in enumerate(set_ids)} + + # Postprocess + for set_name, metrics in reduced_metrics.items(): + count = metrics.pop("count") + reduced_metrics[set_name] = {k: v / count for k, v in metrics.items()} + + return reduced_metrics + + +def save_code_and_config(config: PretrainConfig): + if config.checkpoint_path is None or wandb.run is None: + return + + os.makedirs(config.checkpoint_path, exist_ok=True) + + # Copy code + code_list = [ + get_model_source_path(config.arch.name), + get_model_source_path(config.arch.loss.name) + ] + for code_file in code_list: + if code_file is not None: + code_name = os.path.basename(code_file) + + shutil.copy(code_file, os.path.join(config.checkpoint_path, code_name)) + + # Dump config as yaml + config_file = os.path.join(config.checkpoint_path, "all_config.yaml") + with open(config_file, "wt") as f: + yaml.dump(config.model_dump(), f) + + # Log code + wandb.run.log_code(config.checkpoint_path) + + +def load_synced_config(hydra_config: DictConfig, rank: int, world_size: int) -> PretrainConfig: + objects = [None] + if rank == 0: + config = PretrainConfig(**hydra_config) # type: ignore + + # Naming + if config.project_name is None: + config.project_name = f"{os.path.basename(config.data_path).capitalize()} ACT-torch" + if config.run_name is None: + config.run_name = f"{config.arch.name.split('@')[-1]} {coolname.generate_slug(2)}" + if config.checkpoint_path is None: + config.checkpoint_path = os.path.join("checkpoints", config.project_name, config.run_name) + + objects = [config] + + if world_size > 1: + dist.broadcast_object_list(objects, src=0) + + return objects[0] # type: ignore + + +@hydra.main(config_path="config", config_name="cfg_pretrain", version_base=None) +def launch(hydra_config: DictConfig): + RANK = 0 + WORLD_SIZE = 1 + + # Initialize distributed training if in distributed environment (e.g. torchrun) + if "LOCAL_RANK" in os.environ: + # Initialize distributed, default device and dtype + dist.init_process_group(backend="nccl") + + RANK = dist.get_rank() + WORLD_SIZE = dist.get_world_size() + + torch.cuda.set_device(int(os.environ["LOCAL_RANK"])) + + # Load sync'ed config + config = load_synced_config(hydra_config, rank=RANK, world_size=WORLD_SIZE) + + # Seed RNGs to ensure consistency + torch.random.manual_seed(config.seed + RANK) + + # Dataset + train_epochs_per_iter = config.eval_interval if config.eval_interval is not None else config.epochs + total_iters = config.epochs // train_epochs_per_iter + + assert config.epochs % train_epochs_per_iter == 0, "Eval interval must be a divisor of total epochs." + + train_loader, train_metadata = create_dataloader(config, "train", test_set_mode=False, epochs_per_iter=train_epochs_per_iter, global_batch_size=config.global_batch_size, rank=RANK, world_size=WORLD_SIZE) + eval_loader, eval_metadata = create_dataloader(config, "test", test_set_mode=True, epochs_per_iter=1, global_batch_size=config.global_batch_size, rank=RANK, world_size=WORLD_SIZE) + + # Train state + train_state = init_train_state(config, train_metadata, world_size=WORLD_SIZE) + + # Progress bar and logger + progress_bar = None + if RANK == 0: + progress_bar = tqdm.tqdm(total=train_state.total_steps) + + wandb.init(project=config.project_name, name=config.run_name, config=config.model_dump(), settings=wandb.Settings(_disable_stats=True)) # type: ignore + wandb.log({"num_params": sum(x.numel() for x in train_state.model.parameters())}, step=0) + save_code_and_config(config) + + # Training Loop + for _iter_id in range(total_iters): + print (f"[Rank {RANK}, World Size {WORLD_SIZE}]: Epoch {_iter_id * train_epochs_per_iter}") + + ############ Train Iter + train_state.model.train() + for set_name, batch, global_batch_size in train_loader: + metrics = train_batch(config, train_state, batch, global_batch_size, rank=RANK, world_size=WORLD_SIZE) + + if RANK == 0 and metrics is not None: + wandb.log(metrics, step=train_state.step) + progress_bar.update(train_state.step - progress_bar.n) # type: ignore + + ############ Evaluation + train_state.model.eval() + metrics = evaluate(config, train_state, eval_loader, eval_metadata, rank=RANK, world_size=WORLD_SIZE) + + if RANK == 0 and metrics is not None: + wandb.log(metrics, step=train_state.step) + + ############ Checkpointing + if RANK == 0 and (config.checkpoint_every_eval or (_iter_id == total_iters - 1)): + save_train_state(config, train_state) + + # finalize + if dist.is_initialized(): + dist.destroy_process_group() + wandb.finish() + + +if __name__ == "__main__": + launch() diff --git a/srm/puzzle_dataset.py b/srm/puzzle_dataset.py new file mode 100644 index 0000000..2782403 --- /dev/null +++ b/srm/puzzle_dataset.py @@ -0,0 +1,199 @@ +import os +import json + +import numpy as np +import pydantic + +import torch +from torch.utils.data import IterableDataset, get_worker_info + +from models.losses import IGNORE_LABEL_ID +from dataset.common import PuzzleDatasetMetadata + + +def _sample_batch(rng: np.random.Generator, group_order: np.ndarray, puzzle_indices: np.ndarray, group_indices: np.ndarray, start_index: int, global_batch_size: int): + # Pack examples into a full batch + batch = [] + batch_puzzle_indices = [] + current_size = 0 + + while (start_index < group_order.size) and (current_size < global_batch_size): + # Pick a group and a puzzle from that group + group_id = group_order[start_index] + puzzle_id = rng.integers(group_indices[group_id], group_indices[group_id + 1]) + start_index += 1 + + # Get range of the puzzle + puzzle_start = puzzle_indices[puzzle_id] + puzzle_size = int(puzzle_indices[puzzle_id + 1] - puzzle_start) + + append_size = min(puzzle_size, global_batch_size - current_size) + + # Put into batch + batch_puzzle_indices.append(np.full(append_size, puzzle_id, dtype=np.int32)) + batch.append(puzzle_start + np.random.choice(puzzle_size, append_size, replace=False)) + + current_size += append_size + + return start_index, np.concatenate(batch), np.concatenate(batch_puzzle_indices) + + +class PuzzleDatasetConfig(pydantic.BaseModel): + seed: int + dataset_path: str + global_batch_size: int + test_set_mode: bool + + epochs_per_iter: int # Batch X epochs in an iteration to reduce overhead. + + rank: int + num_replicas: int + + +class PuzzleDataset(IterableDataset): + def __init__(self, config: PuzzleDatasetConfig, split: str = "train"): + super().__init__() + self.config = config + self.split = split + self.metadata = self._load_metadata() + + # Checks + assert self.config.global_batch_size % self.config.num_replicas == 0, f"Global batch size {self.config.global_batch_size} must be multiples of nodes {self.config.num_replicas}." + self.local_batch_size = self.config.global_batch_size // self.config.num_replicas + + # State + self._data = None + self._iters = 0 + + def _load_metadata(self) -> PuzzleDatasetMetadata: + with open(os.path.join(self.config.dataset_path, self.split, "dataset.json"), "r") as f: + return PuzzleDatasetMetadata(**json.load(f)) + + def _lazy_load_dataset(self): + if self._data is not None: + return + + field_mmap_modes = { + "inputs": "r", + "labels": "r", + + # Keep indices in memory + "puzzle_identifiers": None, + "puzzle_indices": None, + "group_indices": None + } + + # Load data + self._data = {} + for set_name in self.metadata.sets: + # Load subset + self._data[set_name] = { + field_name: np.load(os.path.join(self.config.dataset_path, self.split, f"{set_name}__{field_name}.npy"), mmap_mode=mmap_mode) + for field_name, mmap_mode in field_mmap_modes.items() + } + + def _collate_batch(self, batch): + # Convert dtype + batch = {k: v.astype(np.int32) for k, v in batch.items()} + + # Convert ignore label IDs + if self.metadata.ignore_label_id is not None: + batch["labels"][batch["labels"] == self.metadata.ignore_label_id] = IGNORE_LABEL_ID + + # Pad + if batch["puzzle_identifiers"].size < self.local_batch_size: + pad_size = self.local_batch_size - batch["puzzle_identifiers"].size + + pad_values = { + "inputs": self.metadata.pad_id, + "labels": IGNORE_LABEL_ID, + + "puzzle_identifiers": self.metadata.blank_identifier_id + } + batch = {k: np.pad(v, ((0, pad_size), ) + ((0, 0), ) * (v.ndim - 1), constant_values=pad_values[k]) for k, v in batch.items()} + + # To tensor + return {k: torch.from_numpy(v) for k, v in batch.items()} + + def _iter_test(self): + for set_name, dataset in self._data.items(): # type: ignore + total_examples = len(dataset["inputs"]) + + # Load examples one by one + start_index = 0 + while start_index < total_examples: + # Compute indices + end_index = min(total_examples, start_index + self.config.global_batch_size) + + local_start = start_index + self.config.rank * self.local_batch_size + local_end = min(start_index + (self.config.rank + 1) * self.local_batch_size, end_index) + + # Get batch of examples, and also puzzle IDs + puzzle_indices = [] + puzzle_index = np.searchsorted(dataset["puzzle_indices"], local_start, side="right") - 1 + for i in range(local_start, local_end): + while puzzle_index + 1 < len(dataset["puzzle_indices"]) and i >= dataset["puzzle_indices"][puzzle_index + 1]: + puzzle_index += 1 + + puzzle_indices.append(puzzle_index) + + batch = self._collate_batch({ + "inputs": dataset["inputs"][local_start: local_end], + "labels": dataset["labels"][local_start: local_end], + "puzzle_identifiers": dataset["puzzle_identifiers"][puzzle_indices] + }) + + yield set_name, batch, end_index - start_index + + # Advance to next batch + start_index += self.config.global_batch_size + + def _iter_train(self): + for set_name, dataset in self._data.items(): # type: ignore + # Increase epoch count + self._iters += 1 + + # Randomly shuffle groups + rng = np.random.Generator(np.random.Philox(seed=self.config.seed + self._iters)) + + group_order = np.concatenate([rng.permutation(dataset["group_indices"].size - 1) for _i in range(self.config.epochs_per_iter)]) + start_index = 0 + + while start_index < group_order.size: + start_index, batch_indices, batch_puzzle_indices = _sample_batch( + rng, + group_order=group_order, + puzzle_indices=dataset["puzzle_indices"], + group_indices=dataset["group_indices"], + start_index=start_index, + global_batch_size=self.config.global_batch_size, + ) + + # Select current rank and collate + global_effective_batch_size = batch_puzzle_indices.size # Global effective batch size, excluding pads + + # Drop last batch + if global_effective_batch_size < self.config.global_batch_size: + break + + batch_indices = batch_indices [self.config.rank * self.local_batch_size: (self.config.rank + 1) * self.local_batch_size] + batch_puzzle_indices = batch_puzzle_indices[self.config.rank * self.local_batch_size: (self.config.rank + 1) * self.local_batch_size] + batch = self._collate_batch({ + "inputs": dataset["inputs"][batch_indices], + "labels": dataset["labels"][batch_indices], + "puzzle_identifiers": dataset["puzzle_identifiers"][batch_puzzle_indices] + }) + + yield set_name, batch, global_effective_batch_size + + def __iter__(self): + worker_info = get_worker_info() + assert worker_info is None or worker_info.num_workers == 1, "Multithreaded data loading is not currently supported." + + self._lazy_load_dataset() + + # Iterate using specified mode + if self.config.test_set_mode: + yield from self._iter_test() + else: + yield from self._iter_train() diff --git a/srm/puzzle_visualizer.html b/srm/puzzle_visualizer.html new file mode 100644 index 0000000..bcefdf1 --- /dev/null +++ b/srm/puzzle_visualizer.html @@ -0,0 +1,426 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="UTF-8" /> + <title>ARC‐Converted Dataset Visualizer (Upload Local Folder)</title> + <style> + body { + font-family: sans-serif; + margin: 16px; + } + .selector-area { + margin-bottom: 1rem; + } + .grid-canvas { + margin: 4px; + border: 1px solid #ccc; + } + .example-container { + display: inline-block; + margin: 0 16px 16px 0; + vertical-align: top; + } + .puzzle-display { + margin-top: 1rem; + } + .puzzle-id { + font-weight: bold; + margin-bottom: 0.5rem; + } + #groupList, #puzzleList { + margin: 1rem 0; + } + .group-item, .puzzle-item { + cursor: pointer; + margin: 4px 8px 4px 0; + padding: 2px 6px; + border: 1px solid #aaa; + display: inline-block; + } + .group-item:hover, .puzzle-item:hover { + background: #eef; + } + </style> +</head> +<body> +<h1>ARC‐Converted Dataset Visualizer (Local Directory)</h1> + +<div class="selector-area"> + <!-- 1) Directory input with webkitdirectory, mozdirectory --> + <label>Upload ARC Folder:</label> + <input type="file" id="folderInput" + webkitdirectory mozdirectory multiple + onchange="onFolderSelected(event)" /> + <br><br> + + <!-- 2) We'll enable set/subset selection after user chooses a folder and data is validated --> + <label>Set:</label> + <select id="setSelect" disabled> + <option value="train">train</option> + <option value="test">test</option> + </select> + + <label> Subset:</label> + <select id="subsetSelect" disabled> + <option value="all">all</option> + </select> + + <button id="loadBtn" disabled>Load</button> +</div> + +<div> + <div id="groupList"></div> + <div id="puzzleList"></div> + <div class="puzzle-display" id="puzzleView"></div> +</div> + +<!-- + 3) Use local 'assets/npyjs.js' from your project folder instead of a CDN. + Make sure 'assets/npyjs.js' is the unbundled or UMD version that doesn't + contain "import" statements. +--> +<script src="assets/npyjs.js"></script> + +<script> +/*************************************************************************** + * Global Maps & Variables + ***************************************************************************/ + +// Map from "train/all__inputs.npy" => File, etc. +let filesByPath = {}; + +// Once loaded, we store typed arrays for the chosen set/subset +let inputsArr, labelsArr; +let puzzleIndicesArr, groupIndicesArr, puzzleIdentifiersArr; +let identifiersJson; + +// The shape of inputs is [N_examples, seqLen], so we discover seqLen & gridSize +let seqLen = 0; +let gridSize = 0; + + +/*************************************************************************** + * 1) Handle folder selection: read all files, find identifiers.json, + * remove topmost folder from each file path, validate. + ***************************************************************************/ +function onFolderSelected(event) { + filesByPath = {}; + const fileList = event.target.files; + if (!fileList || fileList.length === 0) { + alert("No files selected!"); + return; + } + + // We'll gather all webkitRelativePaths + const paths = []; + for (let i = 0; i < fileList.length; i++) { + // Typically "arc-aug-10/train/all__inputs.npy", etc. + const file = fileList[i]; + const relPath = file.webkitRelativePath || file.mozRelativePath || file.name; + paths.push(relPath); + } + + // 1. Check if we have "identifiers.json" somewhere. + const idPath = paths.find(p => p.endsWith("identifiers.json")); + if (!idPath) { + alert("Error: No 'identifiers.json' found in the uploaded folder."); + return; + } + + // 2. Derive the top-level directory from that file's path + // e.g. if idPath = "arc-aug-10/identifiers.json", topDir = "arc-aug-10" + // If there's no slash, topDir = "" => do nothing + let topDir = ""; + const lastSlash = idPath.lastIndexOf("/"); + if (lastSlash >= 0) { + topDir = idPath.substring(0, lastSlash); + } + + // 3. Rebuild filesByPath with the top folder removed. + // For example, if topDir = "arc-aug-10", then "arc-aug-10/train/all__inputs.npy" + // becomes "train/all__inputs.npy" + for (let i = 0; i < fileList.length; i++) { + const file = fileList[i]; + let relPath = file.webkitRelativePath || file.mozRelativePath || file.name; + // If relPath starts with "arc-aug-10/", remove that prefix + if (topDir && relPath.startsWith(topDir + "/")) { + relPath = relPath.substring(topDir.length + 1); + } + filesByPath[relPath] = file; + } + + // Enable set/subset selection and "Load" + document.getElementById("setSelect").disabled = false; + document.getElementById("subsetSelect").disabled = false; + document.getElementById("loadBtn").disabled = false; +} + +// When user clicks "Load," parse the .npy for the chosen set/subset +document.getElementById("loadBtn").addEventListener("click", async () => { + document.getElementById("groupList").innerHTML = ""; + document.getElementById("puzzleList").innerHTML = ""; + document.getElementById("puzzleView").innerHTML = ""; + + const setName = document.getElementById("setSelect").value; // e.g. "train" + const subsetName = document.getElementById("subsetSelect").value; // e.g. "all" + + try { + await loadDataset(setName, subsetName); + buildGroupList(); // show groups + } catch (err) { + console.error(err); + alert("Error while loading dataset: " + err); + } +}); + + +/*************************************************************************** + * 2) Load .npy from local files using Npyjs + FileReader (ArrayBuffer) + ***************************************************************************/ +async function loadDataset(setName, subsetName) { + const prefix = `${setName}/${subsetName}__`; + // e.g. "train/all__inputs.npy" + const inputsPath = prefix + "inputs.npy"; + const labelsPath = prefix + "labels.npy"; + const pIdxPath = prefix + "puzzle_indices.npy"; + const gIdxPath = prefix + "group_indices.npy"; + const pIdsPath = prefix + "puzzle_identifiers.npy"; + const identifiersPath = "identifiers.json"; + + // Check existence + const needed = [inputsPath, labelsPath, pIdxPath, gIdxPath, pIdsPath, identifiersPath]; + for (const f of needed) { + if (!filesByPath[f]) { + throw new Error(`Missing file: ${f}`); + } + } + + // parseNpy => read from File -> ArrayBuffer -> Npyjs => typed array + const inputsNpy = await parseNpy(filesByPath[inputsPath]); + const labelsNpy = await parseNpy(filesByPath[labelsPath]); + const puzzleIndicesNpy= await parseNpy(filesByPath[pIdxPath]); + const groupIndicesNpy = await parseNpy(filesByPath[gIdxPath]); + const puzzleIdsNpy = await parseNpy(filesByPath[pIdsPath]); + + inputsArr = inputsNpy.data; + labelsArr = labelsNpy.data; + puzzleIndicesArr = puzzleIndicesNpy.data; + groupIndicesArr = groupIndicesNpy.data; + puzzleIdentifiersArr = puzzleIdsNpy.data; + + // shape e.g. [N_examples, seqLen] + seqLen = inputsNpy.shape[1]; + gridSize = Math.sqrt(seqLen); + + // read JSON + identifiersJson = await readJsonFile(filesByPath[identifiersPath]); +} + +/*************************************************************************** + * parseNpy => read a File as ArrayBuffer, parse with npyjs + ***************************************************************************/ +function parseNpy(file) { + return new Promise((resolve, reject) => { + const reader = new FileReader(); + reader.onload = async () => { + try { + const arrayBuffer = reader.result; + const npy = new npyjs(); + resolve(await npy.parse(arrayBuffer)); + } catch (err) { + reject(err); + } + }; + reader.onerror = err => reject(err); + reader.readAsArrayBuffer(file); + }); +} + +/*************************************************************************** + * readJsonFile => read a local JSON file into object + ***************************************************************************/ +function readJsonFile(file) { + return new Promise((resolve, reject) => { + const reader = new FileReader(); + reader.onload = () => { + try { + const obj = JSON.parse(reader.result); + resolve(obj); + } catch (err) { + reject(err); + } + }; + reader.onerror = (err) => reject(err); + reader.readAsText(file); + }); +} + +/*************************************************************************** + * 3) Build group list in UI + ***************************************************************************/ +function buildGroupList() { + document.getElementById("groupList").innerHTML = "<h3>Groups</h3>"; + const groupListDiv = document.getElementById("groupList"); + + const nGroups = groupIndicesArr.length - 1; + for (let g = 0; g < nGroups; g++) { + const div = document.createElement("span"); + div.className = "group-item"; + div.textContent = `Group ${g}`; + div.onclick = () => onSelectGroup(g); + groupListDiv.appendChild(div); + } +} + +/*************************************************************************** + * onSelectGroup => show puzzles in that group + ***************************************************************************/ +function onSelectGroup(groupIndex) { + document.getElementById("puzzleList").innerHTML = ""; + document.getElementById("puzzleView").innerHTML = ""; + + const puzzleListDiv = document.getElementById("puzzleList"); + puzzleListDiv.innerHTML = `<h4>Puzzles in Group ${groupIndex}</h4>`; + + const firstPuzzle = groupIndicesArr[groupIndex]; + const lastPuzzle = groupIndicesArr[groupIndex + 1]; + + for (let p = firstPuzzle; p < lastPuzzle; p++) { + const puzzleIntId = puzzleIdentifiersArr[p]; + const puzzleStrId = (puzzleIntId < identifiersJson.length) + ? identifiersJson[puzzleIntId] + : "<unknown>"; + + const div = document.createElement("span"); + div.className = "puzzle-item"; + div.textContent = `Puzzle #${p} [ID=${puzzleIntId}: ${puzzleStrId}]`; + div.onclick = () => onSelectPuzzle(p); + puzzleListDiv.appendChild(div); + } +} + +/*************************************************************************** + * onSelectPuzzle => show each example + ***************************************************************************/ +function onSelectPuzzle(puzzleIndex) { + const puzzleView = document.getElementById("puzzleView"); + puzzleView.innerHTML = ""; + + // puzzle ID + const puzzleIntId = puzzleIdentifiersArr[puzzleIndex]; + const puzzleStrId = (puzzleIntId < identifiersJson.length) + ? identifiersJson[puzzleIntId] + : "<unknown>"; + + const titleDiv = document.createElement("div"); + titleDiv.className = "puzzle-id"; + titleDiv.textContent = `Puzzle #${puzzleIndex} — ID: ${puzzleStrId}`; + puzzleView.appendChild(titleDiv); + + // Examples are [puzzleIndicesArr[p], puzzleIndicesArr[p+1]) + const firstExample = puzzleIndicesArr[puzzleIndex]; + const lastExample = puzzleIndicesArr[puzzleIndex + 1]; + + for (let e = firstExample; e < lastExample; e++) { + const inputSeq = slice1D(inputsArr, e*seqLen, (e+1)*seqLen); + const outputSeq = slice1D(labelsArr, e*seqLen, (e+1)*seqLen); + + const inputGrid = decodeGrid(inputSeq); + const outputGrid = decodeGrid(outputSeq); + + const exDiv = document.createElement("div"); + exDiv.className = "example-container"; + exDiv.appendChild(document.createTextNode(`Example ${e}`)); + exDiv.appendChild(document.createElement("br")); + + exDiv.appendChild(renderGrid(inputGrid)); + exDiv.appendChild(renderGrid(outputGrid)); + + puzzleView.appendChild(exDiv); + } +} + +/*************************************************************************** + * slice1D => typed array slicing + ***************************************************************************/ +function slice1D(arr, start, end) { + const result = new Uint32Array(end - start); + for (let i = start; i < end; i++) { + result[i - start] = Number(arr[i]); + } + return result; +} + +/*************************************************************************** + * decodeGrid => turn the flattened seq of length=gridSize^2 into 2D + ***************************************************************************/ +function decodeGrid(seq) { + const grid = []; + let idx = 0; + for (let r = 0; r < gridSize; r++) { + const row = []; + for (let c = 0; c < gridSize; c++) { + row.push(seq[idx]); + idx++; + } + grid.push(row); + } + return grid; +} + +/*************************************************************************** + * renderGrid => draws a 2D grid to <canvas> + ***************************************************************************/ +function renderGrid(grid2d) { + const rows = grid2d.length; + const cols = grid2d[0].length; + const scale = 10; + + const canvas = document.createElement("canvas"); + canvas.width = cols * scale; + canvas.height = rows * scale; + canvas.className = "grid-canvas"; + const ctx = canvas.getContext("2d"); + + for (let r = 0; r < rows; r++) { + for (let c = 0; c < cols; c++) { + const val = grid2d[r][c]; + ctx.fillStyle = indexToColor(val); + ctx.fillRect(c * scale, r * scale, scale, scale); + } + } + return canvas; +} + +/*************************************************************************** + * indexToColor => color palette: + * 0 => pad => white + * 1 => eos => light gray + * 2..11 => original color(0..9) + ***************************************************************************/ +function indexToColor(value) { + if (value === 0) return "#FFFFFF"; // pad => white + if (value === 1) return "#DDDDDD"; // eos => light gray + + // shift by 2 => original color in [0..9] + const colorIdx = value - 2; + const palette = [ + "#000000", // color0 => black + "#FF0000", // color1 => red + "#00FF00", // color2 => green + "#0000FF", // color3 => blue + "#FFFF00", // color4 => yellow + "#FFA500", // color5 => orange + "#800080", // color6 => purple + "#00FFFF", // color7 => cyan + "#FFC0CB", // color8 => pink + "#808080" // color9 => gray + ]; + if (colorIdx >= 0 && colorIdx < palette.length) { + return palette[colorIdx]; + } + return "#FFFFFF"; // fallback +} +</script> +</body> +</html> diff --git a/srm/requirements.txt b/srm/requirements.txt new file mode 100644 index 0000000..8c90d6f --- /dev/null +++ b/srm/requirements.txt @@ -0,0 +1,11 @@ +torch +adam-atan2 +einops +tqdm +coolname +pydantic +argdantic +wandb +omegaconf +hydra-core +huggingface_hub diff --git a/srm/runs/hrm_orth_v2_sudoku1k_3k.json b/srm/runs/hrm_orth_v2_sudoku1k_3k.json new file mode 100644 index 0000000..b057f37 --- /dev/null +++ b/srm/runs/hrm_orth_v2_sudoku1k_3k.json @@ -0,0 +1,15089 @@ +{ + "args": { + "data_path": "/home/yurenh2/rrm/data/sudoku-extreme-1k-aug-1000", + "n_steps": 3000, + "batch_size": 8, + "lr": 0.0001, + "puzzle_emb_lr": 0.0001, + "warmup_steps": 200, + "weight_decay": 1.0, + "hidden_size": 256, + "num_heads": 4, + "H_cycles": 2, + "L_cycles": 2, + "H_layers": 4, + "L_layers": 4, + "orth_s_min": 0.85, + "cosine_attn_tau": 1.0, + "seed": 42, + "eval_every": 300, + "eval_n": 512, + "eval_batch_size": 32, + "out": "runs/hrm_orth_v2_sudoku1k_3k.json", + "save_ckpt": "ckpts/hrm_orth_v2_3k.pt" + }, + "n_params": 3160082, + "initial_acc": 0.0, + "initial_tok_acc": 0.1111111111111111, + "steps": [ + { + "step": 0, + "lr": 0.0, + "sup_loss": 2.4230187225516246 + }, + { + "step": 1, + "lr": 5e-07, + "sup_loss": 2.422976212095003 + }, + { + "step": 2, + "lr": 1e-06, + "sup_loss": 2.4228976437225147 + }, + { + "step": 3, + "lr": 1.5e-06, + "sup_loss": 2.4228858521076906 + }, + { + "step": 4, + "lr": 2e-06, + "sup_loss": 2.4227188441760377 + }, + { + "step": 5, + "lr": 2.5e-06, + "sup_loss": 2.4225932532529373 + }, + { + "step": 6, + "lr": 3e-06, + "sup_loss": 2.4225069879029126 + }, + { + "step": 7, + "lr": 3.5e-06, + "sup_loss": 2.4223238817272894 + }, + { + "step": 8, + "lr": 4e-06, + "sup_loss": 2.42204633100353 + }, + { + "step": 9, + "lr": 4.5e-06, + "sup_loss": 2.421838297822653 + }, + { + "step": 10, + "lr": 5e-06, + "sup_loss": 2.4215804683341826 + }, + { + "step": 11, + "lr": 5.500000000000001e-06, + "sup_loss": 2.421320949404686 + }, + { + "step": 12, + "lr": 6e-06, + "sup_loss": 2.4209357814777537 + }, + { + "step": 13, + "lr": 6.5000000000000004e-06, + "sup_loss": 2.4205413168232193 + }, + { + "step": 14, + "lr": 7e-06, + "sup_loss": 2.4204142347865814 + }, + { + "step": 15, + "lr": 7.5e-06, + "sup_loss": 2.419884138851487 + }, + { + "step": 16, + "lr": 8e-06, + "sup_loss": 2.4194892188850377 + }, + { + "step": 17, + "lr": 8.5e-06, + "sup_loss": 2.4190010521543246 + }, + { + "step": 18, + "lr": 9e-06, + "sup_loss": 2.4186638181261833 + }, + { + "step": 19, + "lr": 9.5e-06, + "sup_loss": 2.418257297372776 + }, + { + "step": 20, + "lr": 1e-05, + "sup_loss": 2.417699549273716 + }, + { + "step": 21, + "lr": 1.0500000000000001e-05, + "sup_loss": 2.4171774254861313 + }, + { + "step": 22, + "lr": 1.1000000000000001e-05, + "sup_loss": 2.4169202422535223 + }, + { + "step": 23, + "lr": 1.15e-05, + "sup_loss": 2.4161524626364486 + }, + { + "step": 24, + "lr": 1.2e-05, + "sup_loss": 2.4155946588018797 + }, + { + "step": 25, + "lr": 1.25e-05, + "sup_loss": 2.415109791738878 + }, + { + "step": 26, + "lr": 1.3000000000000001e-05, + "sup_loss": 2.414588679965446 + }, + { + "step": 27, + "lr": 1.3500000000000001e-05, + "sup_loss": 2.4145133010540034 + }, + { + "step": 28, + "lr": 1.4e-05, + "sup_loss": 2.41330375317468 + }, + { + "step": 29, + "lr": 1.4500000000000002e-05, + "sup_loss": 2.412920103191364 + }, + { + "step": 30, + "lr": 1.5e-05, + "sup_loss": 2.4123001170675438 + }, + { + "step": 31, + "lr": 1.55e-05, + "sup_loss": 2.4115715464042413 + }, + { + "step": 32, + "lr": 1.6e-05, + "sup_loss": 2.411056728592412 + }, + { + "step": 33, + "lr": 1.65e-05, + "sup_loss": 2.4106307718459723 + }, + { + "step": 34, + "lr": 1.7e-05, + "sup_loss": 2.4100338590427492 + }, + { + "step": 35, + "lr": 1.7500000000000002e-05, + "sup_loss": 2.4095289153863324 + }, + { + "step": 36, + "lr": 1.8e-05, + "sup_loss": 2.4092090568565276 + }, + { + "step": 37, + "lr": 1.8500000000000002e-05, + "sup_loss": 2.4082591368620165 + }, + { + "step": 38, + "lr": 1.9e-05, + "sup_loss": 2.4077808620795658 + }, + { + "step": 39, + "lr": 1.95e-05, + "sup_loss": 2.4069713764177414 + }, + { + "step": 40, + "lr": 2e-05, + "sup_loss": 2.406628769142508 + }, + { + "step": 41, + "lr": 2.05e-05, + "sup_loss": 2.406119457536488 + }, + { + "step": 42, + "lr": 2.1000000000000002e-05, + "sup_loss": 2.4054207586289618 + }, + { + "step": 43, + "lr": 2.15e-05, + "sup_loss": 2.4048746421476084 + }, + { + "step": 44, + "lr": 2.2000000000000003e-05, + "sup_loss": 2.403770564283945 + }, + { + "step": 45, + "lr": 2.25e-05, + "sup_loss": 2.403891411349292 + }, + { + "step": 46, + "lr": 2.3e-05, + "sup_loss": 2.4030750649844586 + }, + { + "step": 47, + "lr": 2.3500000000000002e-05, + "sup_loss": 2.4023760065016972 + }, + { + "step": 48, + "lr": 2.4e-05, + "sup_loss": 2.401816192384602 + }, + { + "step": 49, + "lr": 2.45e-05, + "sup_loss": 2.401454787178186 + }, + { + "step": 50, + "lr": 2.5e-05, + "sup_loss": 2.4004120143514776 + }, + { + "step": 51, + "lr": 2.5500000000000003e-05, + "sup_loss": 2.400103166282266 + }, + { + "step": 52, + "lr": 2.6000000000000002e-05, + "sup_loss": 2.4007997760755617 + }, + { + "step": 53, + "lr": 2.65e-05, + "sup_loss": 2.399265624858679 + }, + { + "step": 54, + "lr": 2.7000000000000002e-05, + "sup_loss": 2.3991356972696596 + }, + { + "step": 55, + "lr": 2.7500000000000004e-05, + "sup_loss": 2.3983918337454 + }, + { + "step": 56, + "lr": 2.8e-05, + "sup_loss": 2.3977029356148223 + }, + { + "step": 57, + "lr": 2.85e-05, + "sup_loss": 2.3972202280127 + }, + { + "step": 58, + "lr": 2.9000000000000004e-05, + "sup_loss": 2.3968761333767272 + }, + { + "step": 59, + "lr": 2.95e-05, + "sup_loss": 2.397206216029772 + }, + { + "step": 60, + "lr": 3e-05, + "sup_loss": 2.396293998439513 + }, + { + "step": 61, + "lr": 3.0500000000000003e-05, + "sup_loss": 2.3955032652019197 + }, + { + "step": 62, + "lr": 3.1e-05, + "sup_loss": 2.395367999196229 + }, + { + "step": 63, + "lr": 3.15e-05, + "sup_loss": 2.3949730327896153 + }, + { + "step": 64, + "lr": 3.2e-05, + "sup_loss": 2.3947352187266953 + }, + { + "step": 65, + "lr": 3.2500000000000004e-05, + "sup_loss": 2.3934656116891273 + }, + { + "step": 66, + "lr": 3.3e-05, + "sup_loss": 2.393570359841634 + }, + { + "step": 67, + "lr": 3.35e-05, + "sup_loss": 2.39343200406159 + }, + { + "step": 68, + "lr": 3.4e-05, + "sup_loss": 2.392451244116361 + }, + { + "step": 69, + "lr": 3.4500000000000005e-05, + "sup_loss": 2.3923304812598176 + }, + { + "step": 70, + "lr": 3.5000000000000004e-05, + "sup_loss": 2.391651695582709 + }, + { + "step": 71, + "lr": 3.55e-05, + "sup_loss": 2.3912413433888506 + }, + { + "step": 72, + "lr": 3.6e-05, + "sup_loss": 2.391189617239405 + }, + { + "step": 73, + "lr": 3.65e-05, + "sup_loss": 2.390944214297049 + }, + { + "step": 74, + "lr": 3.7000000000000005e-05, + "sup_loss": 2.390090866824547 + }, + { + "step": 75, + "lr": 3.7500000000000003e-05, + "sup_loss": 2.3892358903359603 + }, + { + "step": 76, + "lr": 3.8e-05, + "sup_loss": 2.389287736187517 + }, + { + "step": 77, + "lr": 3.85e-05, + "sup_loss": 2.3888172655363893 + }, + { + "step": 78, + "lr": 3.9e-05, + "sup_loss": 2.3881135357088508 + }, + { + "step": 79, + "lr": 3.9500000000000005e-05, + "sup_loss": 2.3874132948653464 + }, + { + "step": 80, + "lr": 4e-05, + "sup_loss": 2.3873603278800326 + }, + { + "step": 81, + "lr": 4.0499999999999995e-05, + "sup_loss": 2.386735960011197 + }, + { + "step": 82, + "lr": 4.1e-05, + "sup_loss": 2.3870060222822356 + }, + { + "step": 83, + "lr": 4.15e-05, + "sup_loss": 2.385931320407727 + }, + { + "step": 84, + "lr": 4.2000000000000004e-05, + "sup_loss": 2.3854421834545168 + }, + { + "step": 85, + "lr": 4.25e-05, + "sup_loss": 2.385331534790408 + }, + { + "step": 86, + "lr": 4.3e-05, + "sup_loss": 2.3848678740199505 + }, + { + "step": 87, + "lr": 4.350000000000001e-05, + "sup_loss": 2.3844577171269807 + }, + { + "step": 88, + "lr": 4.4000000000000006e-05, + "sup_loss": 2.3831926664210124 + }, + { + "step": 89, + "lr": 4.45e-05, + "sup_loss": 2.3829245203951115 + }, + { + "step": 90, + "lr": 4.5e-05, + "sup_loss": 2.382873568912992 + }, + { + "step": 91, + "lr": 4.55e-05, + "sup_loss": 2.3820243800831475 + }, + { + "step": 92, + "lr": 4.6e-05, + "sup_loss": 2.3817348958237425 + }, + { + "step": 93, + "lr": 4.6500000000000005e-05, + "sup_loss": 2.381489354226036 + }, + { + "step": 94, + "lr": 4.7000000000000004e-05, + "sup_loss": 2.380313369097743 + }, + { + "step": 95, + "lr": 4.7499999999999996e-05, + "sup_loss": 2.3801445942292836 + }, + { + "step": 96, + "lr": 4.8e-05, + "sup_loss": 2.379352575497288 + }, + { + "step": 97, + "lr": 4.85e-05, + "sup_loss": 2.3789825493695878 + }, + { + "step": 98, + "lr": 4.9e-05, + "sup_loss": 2.377987795226529 + }, + { + "step": 99, + "lr": 4.9500000000000004e-05, + "sup_loss": 2.3778388917948616 + }, + { + "step": 100, + "lr": 5e-05, + "sup_loss": 2.377746513136505 + }, + { + "step": 101, + "lr": 5.050000000000001e-05, + "sup_loss": 2.3769782820862484 + }, + { + "step": 102, + "lr": 5.1000000000000006e-05, + "sup_loss": 2.3761579975194107 + }, + { + "step": 103, + "lr": 5.15e-05, + "sup_loss": 2.3753258359733667 + }, + { + "step": 104, + "lr": 5.2000000000000004e-05, + "sup_loss": 2.375149797648807 + }, + { + "step": 105, + "lr": 5.25e-05, + "sup_loss": 2.374692638013552 + }, + { + "step": 106, + "lr": 5.3e-05, + "sup_loss": 2.373980627984928 + }, + { + "step": 107, + "lr": 5.3500000000000006e-05, + "sup_loss": 2.373627270015254 + }, + { + "step": 108, + "lr": 5.4000000000000005e-05, + "sup_loss": 2.3728474015467835 + }, + { + "step": 109, + "lr": 5.4499999999999997e-05, + "sup_loss": 2.3730530813207116 + }, + { + "step": 110, + "lr": 5.500000000000001e-05, + "sup_loss": 2.3720495003294286 + }, + { + "step": 111, + "lr": 5.55e-05, + "sup_loss": 2.371573063488946 + }, + { + "step": 112, + "lr": 5.6e-05, + "sup_loss": 2.3702522642635553 + }, + { + "step": 113, + "lr": 5.6500000000000005e-05, + "sup_loss": 2.3705062606837055 + }, + { + "step": 114, + "lr": 5.7e-05, + "sup_loss": 2.369888284616215 + }, + { + "step": 115, + "lr": 5.75e-05, + "sup_loss": 2.3707432682973337 + }, + { + "step": 116, + "lr": 5.800000000000001e-05, + "sup_loss": 2.3694906434603333 + }, + { + "step": 117, + "lr": 5.85e-05, + "sup_loss": 2.368062851423209 + }, + { + "step": 118, + "lr": 5.9e-05, + "sup_loss": 2.3679887844999614 + }, + { + "step": 119, + "lr": 5.95e-05, + "sup_loss": 2.3678942062379487 + }, + { + "step": 120, + "lr": 6e-05, + "sup_loss": 2.366871819570407 + }, + { + "step": 121, + "lr": 6.050000000000001e-05, + "sup_loss": 2.365920387780834 + }, + { + "step": 122, + "lr": 6.1000000000000005e-05, + "sup_loss": 2.3651245446288875 + }, + { + "step": 123, + "lr": 6.15e-05, + "sup_loss": 2.364668559770104 + }, + { + "step": 124, + "lr": 6.2e-05, + "sup_loss": 2.364103674627576 + }, + { + "step": 125, + "lr": 6.25e-05, + "sup_loss": 2.3635254009766804 + }, + { + "step": 126, + "lr": 6.3e-05, + "sup_loss": 2.363460508611781 + }, + { + "step": 127, + "lr": 6.350000000000001e-05, + "sup_loss": 2.3632989252821806 + }, + { + "step": 128, + "lr": 6.4e-05, + "sup_loss": 2.3623508635320523 + }, + { + "step": 129, + "lr": 6.45e-05, + "sup_loss": 2.362099802571919 + }, + { + "step": 130, + "lr": 6.500000000000001e-05, + "sup_loss": 2.3619695644910412 + }, + { + "step": 131, + "lr": 6.55e-05, + "sup_loss": 2.360518996166771 + }, + { + "step": 132, + "lr": 6.6e-05, + "sup_loss": 2.3601681031346895 + }, + { + "step": 133, + "lr": 6.65e-05, + "sup_loss": 2.3586365887913154 + }, + { + "step": 134, + "lr": 6.7e-05, + "sup_loss": 2.3586287737620073 + }, + { + "step": 135, + "lr": 6.75e-05, + "sup_loss": 2.3575614248156747 + }, + { + "step": 136, + "lr": 6.8e-05, + "sup_loss": 2.356567129615114 + }, + { + "step": 137, + "lr": 6.85e-05, + "sup_loss": 2.3562708690032665 + }, + { + "step": 138, + "lr": 6.900000000000001e-05, + "sup_loss": 2.3557931644750574 + }, + { + "step": 139, + "lr": 6.950000000000001e-05, + "sup_loss": 2.355681502570187 + }, + { + "step": 140, + "lr": 7.000000000000001e-05, + "sup_loss": 2.354514570735801 + }, + { + "step": 141, + "lr": 7.05e-05, + "sup_loss": 2.3529816474444916 + }, + { + "step": 142, + "lr": 7.1e-05, + "sup_loss": 2.353554187486562 + }, + { + "step": 143, + "lr": 7.15e-05, + "sup_loss": 2.3532876957757924 + }, + { + "step": 144, + "lr": 7.2e-05, + "sup_loss": 2.3511172207566786 + }, + { + "step": 145, + "lr": 7.25e-05, + "sup_loss": 2.3518022651863846 + }, + { + "step": 146, + "lr": 7.3e-05, + "sup_loss": 2.3502395311547635 + }, + { + "step": 147, + "lr": 7.350000000000001e-05, + "sup_loss": 2.349900499211024 + }, + { + "step": 148, + "lr": 7.400000000000001e-05, + "sup_loss": 2.3511518647567775 + }, + { + "step": 149, + "lr": 7.45e-05, + "sup_loss": 2.3491226636678006 + }, + { + "step": 150, + "lr": 7.500000000000001e-05, + "sup_loss": 2.348160025087433 + }, + { + "step": 151, + "lr": 7.55e-05, + "sup_loss": 2.346870130729985 + }, + { + "step": 152, + "lr": 7.6e-05, + "sup_loss": 2.3463927291718183 + }, + { + "step": 153, + "lr": 7.65e-05, + "sup_loss": 2.3466706610117716 + }, + { + "step": 154, + "lr": 7.7e-05, + "sup_loss": 2.344642809896304 + }, + { + "step": 155, + "lr": 7.75e-05, + "sup_loss": 2.3442511069125698 + }, + { + "step": 156, + "lr": 7.8e-05, + "sup_loss": 2.343317410302026 + }, + { + "step": 157, + "lr": 7.850000000000001e-05, + "sup_loss": 2.3436000330756315 + }, + { + "step": 158, + "lr": 7.900000000000001e-05, + "sup_loss": 2.342758279989403 + }, + { + "step": 159, + "lr": 7.950000000000001e-05, + "sup_loss": 2.3412703136749533 + }, + { + "step": 160, + "lr": 8e-05, + "sup_loss": 2.3405540152817066 + }, + { + "step": 161, + "lr": 8.05e-05, + "sup_loss": 2.3421626079594318 + }, + { + "step": 162, + "lr": 8.099999999999999e-05, + "sup_loss": 2.340029048517533 + }, + { + "step": 163, + "lr": 8.150000000000002e-05, + "sup_loss": 2.3391686195177317 + }, + { + "step": 164, + "lr": 8.2e-05, + "sup_loss": 2.3397390365878596 + }, + { + "step": 165, + "lr": 8.25e-05, + "sup_loss": 2.338041535622851 + }, + { + "step": 166, + "lr": 8.3e-05, + "sup_loss": 2.3370680090504417 + }, + { + "step": 167, + "lr": 8.35e-05, + "sup_loss": 2.337282842156028 + }, + { + "step": 168, + "lr": 8.400000000000001e-05, + "sup_loss": 2.335164343305065 + }, + { + "step": 169, + "lr": 8.450000000000001e-05, + "sup_loss": 2.335807306376825 + }, + { + "step": 170, + "lr": 8.5e-05, + "sup_loss": 2.3345364458508167 + }, + { + "step": 171, + "lr": 8.55e-05, + "sup_loss": 2.333840052079504 + }, + { + "step": 172, + "lr": 8.6e-05, + "sup_loss": 2.33312450822172 + }, + { + "step": 173, + "lr": 8.65e-05, + "sup_loss": 2.3330028035554022 + }, + { + "step": 174, + "lr": 8.700000000000001e-05, + "sup_loss": 2.332481945523426 + }, + { + "step": 175, + "lr": 8.750000000000001e-05, + "sup_loss": 2.331844206276211 + }, + { + "step": 176, + "lr": 8.800000000000001e-05, + "sup_loss": 2.33077706475553 + }, + { + "step": 177, + "lr": 8.85e-05, + "sup_loss": 2.330186674662559 + }, + { + "step": 178, + "lr": 8.9e-05, + "sup_loss": 2.329305912605475 + }, + { + "step": 179, + "lr": 8.95e-05, + "sup_loss": 2.3280921933375565 + }, + { + "step": 180, + "lr": 9e-05, + "sup_loss": 2.3279191494189906 + }, + { + "step": 181, + "lr": 9.05e-05, + "sup_loss": 2.3282631261097313 + }, + { + "step": 182, + "lr": 9.1e-05, + "sup_loss": 2.3264139058453326 + }, + { + "step": 183, + "lr": 9.15e-05, + "sup_loss": 2.325801263769329 + }, + { + "step": 184, + "lr": 9.2e-05, + "sup_loss": 2.32560131612272 + }, + { + "step": 185, + "lr": 9.250000000000001e-05, + "sup_loss": 2.325128702156402 + }, + { + "step": 186, + "lr": 9.300000000000001e-05, + "sup_loss": 2.3249539741993224 + }, + { + "step": 187, + "lr": 9.350000000000001e-05, + "sup_loss": 2.3227171478000836 + }, + { + "step": 188, + "lr": 9.400000000000001e-05, + "sup_loss": 2.322630068663565 + }, + { + "step": 189, + "lr": 9.45e-05, + "sup_loss": 2.320656558378769 + }, + { + "step": 190, + "lr": 9.499999999999999e-05, + "sup_loss": 2.3207166501456524 + }, + { + "step": 191, + "lr": 9.550000000000002e-05, + "sup_loss": 2.3195503956918415 + }, + { + "step": 192, + "lr": 9.6e-05, + "sup_loss": 2.3180243089091794 + }, + { + "step": 193, + "lr": 9.65e-05, + "sup_loss": 2.3186734508670095 + }, + { + "step": 194, + "lr": 9.7e-05, + "sup_loss": 2.3172960785999406 + }, + { + "step": 195, + "lr": 9.75e-05, + "sup_loss": 2.3164525992591205 + }, + { + "step": 196, + "lr": 9.8e-05, + "sup_loss": 2.316142488313171 + }, + { + "step": 197, + "lr": 9.850000000000001e-05, + "sup_loss": 2.315870420253953 + }, + { + "step": 198, + "lr": 9.900000000000001e-05, + "sup_loss": 2.3150450297547316 + }, + { + "step": 199, + "lr": 9.95e-05, + "sup_loss": 2.3137211662204287 + }, + { + "step": 200, + "lr": 0.0001, + "sup_loss": 2.314124050243869 + }, + { + "step": 201, + "lr": 0.0001, + "sup_loss": 2.3126515003441916 + }, + { + "step": 202, + "lr": 0.0001, + "sup_loss": 2.312184964440809 + }, + { + "step": 203, + "lr": 0.0001, + "sup_loss": 2.311587833188339 + }, + { + "step": 204, + "lr": 0.0001, + "sup_loss": 2.310088815550691 + }, + { + "step": 205, + "lr": 0.0001, + "sup_loss": 2.3099886860949397 + }, + { + "step": 206, + "lr": 0.0001, + "sup_loss": 2.309985909117605 + }, + { + "step": 207, + "lr": 0.0001, + "sup_loss": 2.30915782212011 + }, + { + "step": 208, + "lr": 0.0001, + "sup_loss": 2.3078230231945724 + }, + { + "step": 209, + "lr": 0.0001, + "sup_loss": 2.307701068656173 + }, + { + "step": 210, + "lr": 0.0001, + "sup_loss": 2.3068301821742465 + }, + { + "step": 211, + "lr": 0.0001, + "sup_loss": 2.3074818622636344 + }, + { + "step": 212, + "lr": 0.0001, + "sup_loss": 2.3059030134805294 + }, + { + "step": 213, + "lr": 0.0001, + "sup_loss": 2.3051416042181887 + }, + { + "step": 214, + "lr": 0.0001, + "sup_loss": 2.3044936470839623 + }, + { + "step": 215, + "lr": 0.0001, + "sup_loss": 2.304663868971663 + }, + { + "step": 216, + "lr": 0.0001, + "sup_loss": 2.3027295606746683 + }, + { + "step": 217, + "lr": 0.0001, + "sup_loss": 2.3026579169992236 + }, + { + "step": 218, + "lr": 0.0001, + "sup_loss": 2.3025046556885744 + }, + { + "step": 219, + "lr": 0.0001, + "sup_loss": 2.3010681295498268 + }, + { + "step": 220, + "lr": 0.0001, + "sup_loss": 2.299992239726489 + }, + { + "step": 221, + "lr": 0.0001, + "sup_loss": 2.3013100733977296 + }, + { + "step": 222, + "lr": 0.0001, + "sup_loss": 2.299499756135417 + }, + { + "step": 223, + "lr": 0.0001, + "sup_loss": 2.2988447044873035 + }, + { + "step": 224, + "lr": 0.0001, + "sup_loss": 2.300064707876131 + }, + { + "step": 225, + "lr": 0.0001, + "sup_loss": 2.297157407772141 + }, + { + "step": 226, + "lr": 0.0001, + "sup_loss": 2.2972597985794727 + }, + { + "step": 227, + "lr": 0.0001, + "sup_loss": 2.2959057320800915 + }, + { + "step": 228, + "lr": 0.0001, + "sup_loss": 2.295315042969452 + }, + { + "step": 229, + "lr": 0.0001, + "sup_loss": 2.2956242934356568 + }, + { + "step": 230, + "lr": 0.0001, + "sup_loss": 2.2955530062307323 + }, + { + "step": 231, + "lr": 0.0001, + "sup_loss": 2.293959598775576 + }, + { + "step": 232, + "lr": 0.0001, + "sup_loss": 2.293270755124628 + }, + { + "step": 233, + "lr": 0.0001, + "sup_loss": 2.292761615217784 + }, + { + "step": 234, + "lr": 0.0001, + "sup_loss": 2.292101354218733 + }, + { + "step": 235, + "lr": 0.0001, + "sup_loss": 2.290767431321095 + }, + { + "step": 236, + "lr": 0.0001, + "sup_loss": 2.291012239081484 + }, + { + "step": 237, + "lr": 0.0001, + "sup_loss": 2.290561684149006 + }, + { + "step": 238, + "lr": 0.0001, + "sup_loss": 2.288807304706773 + }, + { + "step": 239, + "lr": 0.0001, + "sup_loss": 2.289549071396752 + }, + { + "step": 240, + "lr": 0.0001, + "sup_loss": 2.288211077328612 + }, + { + "step": 241, + "lr": 0.0001, + "sup_loss": 2.287383342058292 + }, + { + "step": 242, + "lr": 0.0001, + "sup_loss": 2.2877579115855466 + }, + { + "step": 243, + "lr": 0.0001, + "sup_loss": 2.287068919736292 + }, + { + "step": 244, + "lr": 0.0001, + "sup_loss": 2.285504001165305 + }, + { + "step": 245, + "lr": 0.0001, + "sup_loss": 2.2861432728179865 + }, + { + "step": 246, + "lr": 0.0001, + "sup_loss": 2.2850606631193595 + }, + { + "step": 247, + "lr": 0.0001, + "sup_loss": 2.285180497719693 + }, + { + "step": 248, + "lr": 0.0001, + "sup_loss": 2.2846508174853115 + }, + { + "step": 249, + "lr": 0.0001, + "sup_loss": 2.2846181697678927 + }, + { + "step": 250, + "lr": 0.0001, + "sup_loss": 2.2820041981389405 + }, + { + "step": 251, + "lr": 0.0001, + "sup_loss": 2.282932601009815 + }, + { + "step": 252, + "lr": 0.0001, + "sup_loss": 2.2823652608338123 + }, + { + "step": 253, + "lr": 0.0001, + "sup_loss": 2.2808888654247683 + }, + { + "step": 254, + "lr": 0.0001, + "sup_loss": 2.2810911540935006 + }, + { + "step": 255, + "lr": 0.0001, + "sup_loss": 2.28016290022256 + }, + { + "step": 256, + "lr": 0.0001, + "sup_loss": 2.280243310508872 + }, + { + "step": 257, + "lr": 0.0001, + "sup_loss": 2.2794693302328635 + }, + { + "step": 258, + "lr": 0.0001, + "sup_loss": 2.2793106757749353 + }, + { + "step": 259, + "lr": 0.0001, + "sup_loss": 2.2782751894498694 + }, + { + "step": 260, + "lr": 0.0001, + "sup_loss": 2.2782831665302936 + }, + { + "step": 261, + "lr": 0.0001, + "sup_loss": 2.2772936277888576 + }, + { + "step": 262, + "lr": 0.0001, + "sup_loss": 2.2773408537864404 + }, + { + "step": 263, + "lr": 0.0001, + "sup_loss": 2.2760611048401596 + }, + { + "step": 264, + "lr": 0.0001, + "sup_loss": 2.275991396403431 + }, + { + "step": 265, + "lr": 0.0001, + "sup_loss": 2.2751458371666633 + }, + { + "step": 266, + "lr": 0.0001, + "sup_loss": 2.2757921784210193 + }, + { + "step": 267, + "lr": 0.0001, + "sup_loss": 2.2740679862014344 + }, + { + "step": 268, + "lr": 0.0001, + "sup_loss": 2.2735030702092325 + }, + { + "step": 269, + "lr": 0.0001, + "sup_loss": 2.2731910330806526 + }, + { + "step": 270, + "lr": 0.0001, + "sup_loss": 2.272251557223841 + }, + { + "step": 271, + "lr": 0.0001, + "sup_loss": 2.272596547598874 + }, + { + "step": 272, + "lr": 0.0001, + "sup_loss": 2.2716384387639006 + }, + { + "step": 273, + "lr": 0.0001, + "sup_loss": 2.271252468535553 + }, + { + "step": 274, + "lr": 0.0001, + "sup_loss": 2.271751899811348 + }, + { + "step": 275, + "lr": 0.0001, + "sup_loss": 2.270180267583885 + }, + { + "step": 276, + "lr": 0.0001, + "sup_loss": 2.2701773665527623 + }, + { + "step": 277, + "lr": 0.0001, + "sup_loss": 2.269665151291007 + }, + { + "step": 278, + "lr": 0.0001, + "sup_loss": 2.2696164010259507 + }, + { + "step": 279, + "lr": 0.0001, + "sup_loss": 2.2691162772547626 + }, + { + "step": 280, + "lr": 0.0001, + "sup_loss": 2.26797710422096 + }, + { + "step": 281, + "lr": 0.0001, + "sup_loss": 2.268039494965083 + }, + { + "step": 282, + "lr": 0.0001, + "sup_loss": 2.2681881047295445 + }, + { + "step": 283, + "lr": 0.0001, + "sup_loss": 2.2675563605581344 + }, + { + "step": 284, + "lr": 0.0001, + "sup_loss": 2.2667585988803967 + }, + { + "step": 285, + "lr": 0.0001, + "sup_loss": 2.2676289956762035 + }, + { + "step": 286, + "lr": 0.0001, + "sup_loss": 2.2661880815771465 + }, + { + "step": 287, + "lr": 0.0001, + "sup_loss": 2.265242427851795 + }, + { + "step": 288, + "lr": 0.0001, + "sup_loss": 2.2655805031374463 + }, + { + "step": 289, + "lr": 0.0001, + "sup_loss": 2.264430419385871 + }, + { + "step": 290, + "lr": 0.0001, + "sup_loss": 2.264407572139689 + }, + { + "step": 291, + "lr": 0.0001, + "sup_loss": 2.26431362140976 + }, + { + "step": 292, + "lr": 0.0001, + "sup_loss": 2.2638005607574323 + }, + { + "step": 293, + "lr": 0.0001, + "sup_loss": 2.2636235207060955 + }, + { + "step": 294, + "lr": 0.0001, + "sup_loss": 2.2624312598722987 + }, + { + "step": 295, + "lr": 0.0001, + "sup_loss": 2.2631207204715347 + }, + { + "step": 296, + "lr": 0.0001, + "sup_loss": 2.262045568274683 + }, + { + "step": 297, + "lr": 0.0001, + "sup_loss": 2.2621458904867566 + }, + { + "step": 298, + "lr": 0.0001, + "sup_loss": 2.2614729083274634 + }, + { + "step": 299, + "lr": 0.0001, + "sup_loss": 2.261364839246844 + }, + { + "step": 300, + "lr": 0.0001, + "sup_loss": 2.2608058012527685 + }, + { + "step": 301, + "lr": 0.0001, + "sup_loss": 2.2607401268176996 + }, + { + "step": 302, + "lr": 0.0001, + "sup_loss": 2.259707531715066 + }, + { + "step": 303, + "lr": 0.0001, + "sup_loss": 2.259610950786525 + }, + { + "step": 304, + "lr": 0.0001, + "sup_loss": 2.25936405997328 + }, + { + "step": 305, + "lr": 0.0001, + "sup_loss": 2.2592723985880108 + }, + { + "step": 306, + "lr": 0.0001, + "sup_loss": 2.2583823840302752 + }, + { + "step": 307, + "lr": 0.0001, + "sup_loss": 2.2582791454156084 + }, + { + "step": 308, + "lr": 0.0001, + "sup_loss": 2.2577300966343907 + }, + { + "step": 309, + "lr": 0.0001, + "sup_loss": 2.2576649499603128 + }, + { + "step": 310, + "lr": 0.0001, + "sup_loss": 2.2572457434562194 + }, + { + "step": 311, + "lr": 0.0001, + "sup_loss": 2.2569284587592415 + }, + { + "step": 312, + "lr": 0.0001, + "sup_loss": 2.258300741241202 + }, + { + "step": 313, + "lr": 0.0001, + "sup_loss": 2.2576035253303726 + }, + { + "step": 314, + "lr": 0.0001, + "sup_loss": 2.2569916457706594 + }, + { + "step": 315, + "lr": 0.0001, + "sup_loss": 2.2565880122813198 + }, + { + "step": 316, + "lr": 0.0001, + "sup_loss": 2.256449320324531 + }, + { + "step": 317, + "lr": 0.0001, + "sup_loss": 2.2555597029329744 + }, + { + "step": 318, + "lr": 0.0001, + "sup_loss": 2.255787099836545 + }, + { + "step": 319, + "lr": 0.0001, + "sup_loss": 2.255231159589054 + }, + { + "step": 320, + "lr": 0.0001, + "sup_loss": 2.2553060983525173 + }, + { + "step": 321, + "lr": 0.0001, + "sup_loss": 2.254668326281679 + }, + { + "step": 322, + "lr": 0.0001, + "sup_loss": 2.2536269810258682 + }, + { + "step": 323, + "lr": 0.0001, + "sup_loss": 2.2535131111006743 + }, + { + "step": 324, + "lr": 0.0001, + "sup_loss": 2.254023069399638 + }, + { + "step": 325, + "lr": 0.0001, + "sup_loss": 2.2529910408615184 + }, + { + "step": 326, + "lr": 0.0001, + "sup_loss": 2.253427377389489 + }, + { + "step": 327, + "lr": 0.0001, + "sup_loss": 2.2527224341565693 + }, + { + "step": 328, + "lr": 0.0001, + "sup_loss": 2.25244943181775 + }, + { + "step": 329, + "lr": 0.0001, + "sup_loss": 2.2528362178158425 + }, + { + "step": 330, + "lr": 0.0001, + "sup_loss": 2.252467633626436 + }, + { + "step": 331, + "lr": 0.0001, + "sup_loss": 2.2516338435039662 + }, + { + "step": 332, + "lr": 0.0001, + "sup_loss": 2.251120264487262 + }, + { + "step": 333, + "lr": 0.0001, + "sup_loss": 2.251541424461758 + }, + { + "step": 334, + "lr": 0.0001, + "sup_loss": 2.2508384154353838 + }, + { + "step": 335, + "lr": 0.0001, + "sup_loss": 2.2503971338943694 + }, + { + "step": 336, + "lr": 0.0001, + "sup_loss": 2.250350063032028 + }, + { + "step": 337, + "lr": 0.0001, + "sup_loss": 2.249718235692899 + }, + { + "step": 338, + "lr": 0.0001, + "sup_loss": 2.250037332994636 + }, + { + "step": 339, + "lr": 0.0001, + "sup_loss": 2.2494428068263854 + }, + { + "step": 340, + "lr": 0.0001, + "sup_loss": 2.248964298691725 + }, + { + "step": 341, + "lr": 0.0001, + "sup_loss": 2.2484624978171444 + }, + { + "step": 342, + "lr": 0.0001, + "sup_loss": 2.2483134059993795 + }, + { + "step": 343, + "lr": 0.0001, + "sup_loss": 2.248899080804488 + }, + { + "step": 344, + "lr": 0.0001, + "sup_loss": 2.248164089100631 + }, + { + "step": 345, + "lr": 0.0001, + "sup_loss": 2.247291449158167 + }, + { + "step": 346, + "lr": 0.0001, + "sup_loss": 2.247502789577592 + }, + { + "step": 347, + "lr": 0.0001, + "sup_loss": 2.2474663360226836 + }, + { + "step": 348, + "lr": 0.0001, + "sup_loss": 2.2473187887518793 + }, + { + "step": 349, + "lr": 0.0001, + "sup_loss": 2.2469959644713198 + }, + { + "step": 350, + "lr": 0.0001, + "sup_loss": 2.2461702036730866 + }, + { + "step": 351, + "lr": 0.0001, + "sup_loss": 2.2455896548125067 + }, + { + "step": 352, + "lr": 0.0001, + "sup_loss": 2.246318634607909 + }, + { + "step": 353, + "lr": 0.0001, + "sup_loss": 2.2452667227915315 + }, + { + "step": 354, + "lr": 0.0001, + "sup_loss": 2.2448992474643297 + }, + { + "step": 355, + "lr": 0.0001, + "sup_loss": 2.2446522371842934 + }, + { + "step": 356, + "lr": 0.0001, + "sup_loss": 2.244874329450516 + }, + { + "step": 357, + "lr": 0.0001, + "sup_loss": 2.244434639709583 + }, + { + "step": 358, + "lr": 0.0001, + "sup_loss": 2.244808413980027 + }, + { + "step": 359, + "lr": 0.0001, + "sup_loss": 2.2441656592175785 + }, + { + "step": 360, + "lr": 0.0001, + "sup_loss": 2.2438020963409873 + }, + { + "step": 361, + "lr": 0.0001, + "sup_loss": 2.2437427967825254 + }, + { + "step": 362, + "lr": 0.0001, + "sup_loss": 2.243169531617661 + }, + { + "step": 363, + "lr": 0.0001, + "sup_loss": 2.2429614424844146 + }, + { + "step": 364, + "lr": 0.0001, + "sup_loss": 2.2428576569241536 + }, + { + "step": 365, + "lr": 0.0001, + "sup_loss": 2.242748484065763 + }, + { + "step": 366, + "lr": 0.0001, + "sup_loss": 2.2427942437547506 + }, + { + "step": 367, + "lr": 0.0001, + "sup_loss": 2.2418901132320532 + }, + { + "step": 368, + "lr": 0.0001, + "sup_loss": 2.2415890979897624 + }, + { + "step": 369, + "lr": 0.0001, + "sup_loss": 2.2419569274278843 + }, + { + "step": 370, + "lr": 0.0001, + "sup_loss": 2.241585641326611 + }, + { + "step": 371, + "lr": 0.0001, + "sup_loss": 2.2412810312218174 + }, + { + "step": 372, + "lr": 0.0001, + "sup_loss": 2.2407325352420373 + }, + { + "step": 373, + "lr": 0.0001, + "sup_loss": 2.240826313578075 + }, + { + "step": 374, + "lr": 0.0001, + "sup_loss": 2.239571527089285 + }, + { + "step": 375, + "lr": 0.0001, + "sup_loss": 2.2398999875543883 + }, + { + "step": 376, + "lr": 0.0001, + "sup_loss": 2.2404843336288778 + }, + { + "step": 377, + "lr": 0.0001, + "sup_loss": 2.2396431721598304 + }, + { + "step": 378, + "lr": 0.0001, + "sup_loss": 2.2397464983681314 + }, + { + "step": 379, + "lr": 0.0001, + "sup_loss": 2.2393784035959046 + }, + { + "step": 380, + "lr": 0.0001, + "sup_loss": 2.238054726642783 + }, + { + "step": 381, + "lr": 0.0001, + "sup_loss": 2.2391541787573512 + }, + { + "step": 382, + "lr": 0.0001, + "sup_loss": 2.238248187435276 + }, + { + "step": 383, + "lr": 0.0001, + "sup_loss": 2.238795296886966 + }, + { + "step": 384, + "lr": 0.0001, + "sup_loss": 2.238362597121229 + }, + { + "step": 385, + "lr": 0.0001, + "sup_loss": 2.238251426082369 + }, + { + "step": 386, + "lr": 0.0001, + "sup_loss": 2.237526491155277 + }, + { + "step": 387, + "lr": 0.0001, + "sup_loss": 2.237229201250225 + }, + { + "step": 388, + "lr": 0.0001, + "sup_loss": 2.2371069808459176 + }, + { + "step": 389, + "lr": 0.0001, + "sup_loss": 2.2372297602483937 + }, + { + "step": 390, + "lr": 0.0001, + "sup_loss": 2.2375141965461793 + }, + { + "step": 391, + "lr": 0.0001, + "sup_loss": 2.2365701917832586 + }, + { + "step": 392, + "lr": 0.0001, + "sup_loss": 2.236011224789239 + }, + { + "step": 393, + "lr": 0.0001, + "sup_loss": 2.2357994881879835 + }, + { + "step": 394, + "lr": 0.0001, + "sup_loss": 2.235465935541302 + }, + { + "step": 395, + "lr": 0.0001, + "sup_loss": 2.235441778263612 + }, + { + "step": 396, + "lr": 0.0001, + "sup_loss": 2.235246373889105 + }, + { + "step": 397, + "lr": 0.0001, + "sup_loss": 2.235600083826138 + }, + { + "step": 398, + "lr": 0.0001, + "sup_loss": 2.23481326655606 + }, + { + "step": 399, + "lr": 0.0001, + "sup_loss": 2.2347699698234815 + }, + { + "step": 400, + "lr": 0.0001, + "sup_loss": 2.234841006952414 + }, + { + "step": 401, + "lr": 0.0001, + "sup_loss": 2.2341552544763372 + }, + { + "step": 402, + "lr": 0.0001, + "sup_loss": 2.2337605409124848 + }, + { + "step": 403, + "lr": 0.0001, + "sup_loss": 2.2342253004676182 + }, + { + "step": 404, + "lr": 0.0001, + "sup_loss": 2.2338564407170676 + }, + { + "step": 405, + "lr": 0.0001, + "sup_loss": 2.2331218576579897 + }, + { + "step": 406, + "lr": 0.0001, + "sup_loss": 2.233224626289142 + }, + { + "step": 407, + "lr": 0.0001, + "sup_loss": 2.233281764216422 + }, + { + "step": 408, + "lr": 0.0001, + "sup_loss": 2.2327814680589144 + }, + { + "step": 409, + "lr": 0.0001, + "sup_loss": 2.2320631064735856 + }, + { + "step": 410, + "lr": 0.0001, + "sup_loss": 2.232311087420898 + }, + { + "step": 411, + "lr": 0.0001, + "sup_loss": 2.2319754134902436 + }, + { + "step": 412, + "lr": 0.0001, + "sup_loss": 2.2317579876804228 + }, + { + "step": 413, + "lr": 0.0001, + "sup_loss": 2.231512748727236 + }, + { + "step": 414, + "lr": 0.0001, + "sup_loss": 2.2311201342980995 + }, + { + "step": 415, + "lr": 0.0001, + "sup_loss": 2.2313378868519074 + }, + { + "step": 416, + "lr": 0.0001, + "sup_loss": 2.2308926147608856 + }, + { + "step": 417, + "lr": 0.0001, + "sup_loss": 2.230552501068649 + }, + { + "step": 418, + "lr": 0.0001, + "sup_loss": 2.2306446407478266 + }, + { + "step": 419, + "lr": 0.0001, + "sup_loss": 2.230623307394854 + }, + { + "step": 420, + "lr": 0.0001, + "sup_loss": 2.2302269793989073 + }, + { + "step": 421, + "lr": 0.0001, + "sup_loss": 2.2303729314442164 + }, + { + "step": 422, + "lr": 0.0001, + "sup_loss": 2.230036305258701 + }, + { + "step": 423, + "lr": 0.0001, + "sup_loss": 2.2302540339404056 + }, + { + "step": 424, + "lr": 0.0001, + "sup_loss": 2.2293675991770803 + }, + { + "step": 425, + "lr": 0.0001, + "sup_loss": 2.2297891518311492 + }, + { + "step": 426, + "lr": 0.0001, + "sup_loss": 2.2293139431270568 + }, + { + "step": 427, + "lr": 0.0001, + "sup_loss": 2.2293374922855884 + }, + { + "step": 428, + "lr": 0.0001, + "sup_loss": 2.229249020928531 + }, + { + "step": 429, + "lr": 0.0001, + "sup_loss": 2.228801536396908 + }, + { + "step": 430, + "lr": 0.0001, + "sup_loss": 2.228634704088578 + }, + { + "step": 431, + "lr": 0.0001, + "sup_loss": 2.2285590388435326 + }, + { + "step": 432, + "lr": 0.0001, + "sup_loss": 2.2288704321986894 + }, + { + "step": 433, + "lr": 0.0001, + "sup_loss": 2.2285965278169493 + }, + { + "step": 434, + "lr": 0.0001, + "sup_loss": 2.229059060762993 + }, + { + "step": 435, + "lr": 0.0001, + "sup_loss": 2.228366974258089 + }, + { + "step": 436, + "lr": 0.0001, + "sup_loss": 2.2282130043355193 + }, + { + "step": 437, + "lr": 0.0001, + "sup_loss": 2.228170937980424 + }, + { + "step": 438, + "lr": 0.0001, + "sup_loss": 2.227861577248594 + }, + { + "step": 439, + "lr": 0.0001, + "sup_loss": 2.227477986927818 + }, + { + "step": 440, + "lr": 0.0001, + "sup_loss": 2.227349970033629 + }, + { + "step": 441, + "lr": 0.0001, + "sup_loss": 2.227584127083545 + }, + { + "step": 442, + "lr": 0.0001, + "sup_loss": 2.227484344062182 + }, + { + "step": 443, + "lr": 0.0001, + "sup_loss": 2.2277808028970227 + }, + { + "step": 444, + "lr": 0.0001, + "sup_loss": 2.227363348869663 + }, + { + "step": 445, + "lr": 0.0001, + "sup_loss": 2.2278511496579227 + }, + { + "step": 446, + "lr": 0.0001, + "sup_loss": 2.227847921282264 + }, + { + "step": 447, + "lr": 0.0001, + "sup_loss": 2.227433560620211 + }, + { + "step": 448, + "lr": 0.0001, + "sup_loss": 2.2272931546990633 + }, + { + "step": 449, + "lr": 0.0001, + "sup_loss": 2.2269584438691776 + }, + { + "step": 450, + "lr": 0.0001, + "sup_loss": 2.2268888819719153 + }, + { + "step": 451, + "lr": 0.0001, + "sup_loss": 2.226582599226952 + }, + { + "step": 452, + "lr": 0.0001, + "sup_loss": 2.226638675332447 + }, + { + "step": 453, + "lr": 0.0001, + "sup_loss": 2.2266320245432523 + }, + { + "step": 454, + "lr": 0.0001, + "sup_loss": 2.2262804293063065 + }, + { + "step": 455, + "lr": 0.0001, + "sup_loss": 2.2260486826454207 + }, + { + "step": 456, + "lr": 0.0001, + "sup_loss": 2.2265162215182848 + }, + { + "step": 457, + "lr": 0.0001, + "sup_loss": 2.2259235435902474 + }, + { + "step": 458, + "lr": 0.0001, + "sup_loss": 2.226068282518463 + }, + { + "step": 459, + "lr": 0.0001, + "sup_loss": 2.2256875009242605 + }, + { + "step": 460, + "lr": 0.0001, + "sup_loss": 2.225343497515295 + }, + { + "step": 461, + "lr": 0.0001, + "sup_loss": 2.2253289180673788 + }, + { + "step": 462, + "lr": 0.0001, + "sup_loss": 2.2253721339742407 + }, + { + "step": 463, + "lr": 0.0001, + "sup_loss": 2.2243548903887262 + }, + { + "step": 464, + "lr": 0.0001, + "sup_loss": 2.2249634457603733 + }, + { + "step": 465, + "lr": 0.0001, + "sup_loss": 2.224707006017896 + }, + { + "step": 466, + "lr": 0.0001, + "sup_loss": 2.2246318866181243 + }, + { + "step": 467, + "lr": 0.0001, + "sup_loss": 2.2245376981759617 + }, + { + "step": 468, + "lr": 0.0001, + "sup_loss": 2.224335539312312 + }, + { + "step": 469, + "lr": 0.0001, + "sup_loss": 2.224176826122918 + }, + { + "step": 470, + "lr": 0.0001, + "sup_loss": 2.224189035977403 + }, + { + "step": 471, + "lr": 0.0001, + "sup_loss": 2.2237538656000746 + }, + { + "step": 472, + "lr": 0.0001, + "sup_loss": 2.224008844004052 + }, + { + "step": 473, + "lr": 0.0001, + "sup_loss": 2.223983892409622 + }, + { + "step": 474, + "lr": 0.0001, + "sup_loss": 2.2238955117010217 + }, + { + "step": 475, + "lr": 0.0001, + "sup_loss": 2.2233537389900406 + }, + { + "step": 476, + "lr": 0.0001, + "sup_loss": 2.2231939752369 + }, + { + "step": 477, + "lr": 0.0001, + "sup_loss": 2.2234433069976967 + }, + { + "step": 478, + "lr": 0.0001, + "sup_loss": 2.2227565860629075 + }, + { + "step": 479, + "lr": 0.0001, + "sup_loss": 2.2227745666677814 + }, + { + "step": 480, + "lr": 0.0001, + "sup_loss": 2.2225136334736746 + }, + { + "step": 481, + "lr": 0.0001, + "sup_loss": 2.2226730382924416 + }, + { + "step": 482, + "lr": 0.0001, + "sup_loss": 2.222268954934221 + }, + { + "step": 483, + "lr": 0.0001, + "sup_loss": 2.2224787085364657 + }, + { + "step": 484, + "lr": 0.0001, + "sup_loss": 2.2224586608479635 + }, + { + "step": 485, + "lr": 0.0001, + "sup_loss": 2.222253531860658 + }, + { + "step": 486, + "lr": 0.0001, + "sup_loss": 2.221783438358163 + }, + { + "step": 487, + "lr": 0.0001, + "sup_loss": 2.2220292704984517 + }, + { + "step": 488, + "lr": 0.0001, + "sup_loss": 2.221927055817649 + }, + { + "step": 489, + "lr": 0.0001, + "sup_loss": 2.221457886090522 + }, + { + "step": 490, + "lr": 0.0001, + "sup_loss": 2.2214524034424787 + }, + { + "step": 491, + "lr": 0.0001, + "sup_loss": 2.2210578726458237 + }, + { + "step": 492, + "lr": 0.0001, + "sup_loss": 2.2208661226010986 + }, + { + "step": 493, + "lr": 0.0001, + "sup_loss": 2.2210466512324176 + }, + { + "step": 494, + "lr": 0.0001, + "sup_loss": 2.2203705784326995 + }, + { + "step": 495, + "lr": 0.0001, + "sup_loss": 2.2203830051931015 + }, + { + "step": 496, + "lr": 0.0001, + "sup_loss": 2.220532537304697 + }, + { + "step": 497, + "lr": 0.0001, + "sup_loss": 2.22016088664173 + }, + { + "step": 498, + "lr": 0.0001, + "sup_loss": 2.2200174122472456 + }, + { + "step": 499, + "lr": 0.0001, + "sup_loss": 2.2203187538843663 + }, + { + "step": 500, + "lr": 0.0001, + "sup_loss": 2.220041296866742 + }, + { + "step": 501, + "lr": 0.0001, + "sup_loss": 2.2197006600272378 + }, + { + "step": 502, + "lr": 0.0001, + "sup_loss": 2.2196512492766822 + }, + { + "step": 503, + "lr": 0.0001, + "sup_loss": 2.2194999327085556 + }, + { + "step": 504, + "lr": 0.0001, + "sup_loss": 2.219410248136346 + }, + { + "step": 505, + "lr": 0.0001, + "sup_loss": 2.219485541626487 + }, + { + "step": 506, + "lr": 0.0001, + "sup_loss": 2.2191866364821413 + }, + { + "step": 507, + "lr": 0.0001, + "sup_loss": 2.2193491859221943 + }, + { + "step": 508, + "lr": 0.0001, + "sup_loss": 2.21904898179987 + }, + { + "step": 509, + "lr": 0.0001, + "sup_loss": 2.2191759201597363 + }, + { + "step": 510, + "lr": 0.0001, + "sup_loss": 2.219808021239402 + }, + { + "step": 511, + "lr": 0.0001, + "sup_loss": 2.2189789193463407 + }, + { + "step": 512, + "lr": 0.0001, + "sup_loss": 2.218665052369337 + }, + { + "step": 513, + "lr": 0.0001, + "sup_loss": 2.2188276165557617 + }, + { + "step": 514, + "lr": 0.0001, + "sup_loss": 2.2184053077092427 + }, + { + "step": 515, + "lr": 0.0001, + "sup_loss": 2.2187794794400273 + }, + { + "step": 516, + "lr": 0.0001, + "sup_loss": 2.2186606550905807 + }, + { + "step": 517, + "lr": 0.0001, + "sup_loss": 2.218500298035394 + }, + { + "step": 518, + "lr": 0.0001, + "sup_loss": 2.218012299788131 + }, + { + "step": 519, + "lr": 0.0001, + "sup_loss": 2.2184220869530886 + }, + { + "step": 520, + "lr": 0.0001, + "sup_loss": 2.2183401982243494 + }, + { + "step": 521, + "lr": 0.0001, + "sup_loss": 2.2175482796494626 + }, + { + "step": 522, + "lr": 0.0001, + "sup_loss": 2.217772272785234 + }, + { + "step": 523, + "lr": 0.0001, + "sup_loss": 2.2174423927564644 + }, + { + "step": 524, + "lr": 0.0001, + "sup_loss": 2.2171667268742703 + }, + { + "step": 525, + "lr": 0.0001, + "sup_loss": 2.21719806592763 + }, + { + "step": 526, + "lr": 0.0001, + "sup_loss": 2.2173098826480273 + }, + { + "step": 527, + "lr": 0.0001, + "sup_loss": 2.217287150491001 + }, + { + "step": 528, + "lr": 0.0001, + "sup_loss": 2.2175434970005994 + }, + { + "step": 529, + "lr": 0.0001, + "sup_loss": 2.217317219372161 + }, + { + "step": 530, + "lr": 0.0001, + "sup_loss": 2.216866092325656 + }, + { + "step": 531, + "lr": 0.0001, + "sup_loss": 2.2164432453926644 + }, + { + "step": 532, + "lr": 0.0001, + "sup_loss": 2.216340966464691 + }, + { + "step": 533, + "lr": 0.0001, + "sup_loss": 2.216619572851592 + }, + { + "step": 534, + "lr": 0.0001, + "sup_loss": 2.2161272877988663 + }, + { + "step": 535, + "lr": 0.0001, + "sup_loss": 2.216072430882889 + }, + { + "step": 536, + "lr": 0.0001, + "sup_loss": 2.2159943952564696 + }, + { + "step": 537, + "lr": 0.0001, + "sup_loss": 2.215867097755864 + }, + { + "step": 538, + "lr": 0.0001, + "sup_loss": 2.2159937687413294 + }, + { + "step": 539, + "lr": 0.0001, + "sup_loss": 2.215837526399251 + }, + { + "step": 540, + "lr": 0.0001, + "sup_loss": 2.2156341197199607 + }, + { + "step": 541, + "lr": 0.0001, + "sup_loss": 2.2154369565036363 + }, + { + "step": 542, + "lr": 0.0001, + "sup_loss": 2.2157765313799227 + }, + { + "step": 543, + "lr": 0.0001, + "sup_loss": 2.215136750349517 + }, + { + "step": 544, + "lr": 0.0001, + "sup_loss": 2.215367015565356 + }, + { + "step": 545, + "lr": 0.0001, + "sup_loss": 2.2150626371215987 + }, + { + "step": 546, + "lr": 0.0001, + "sup_loss": 2.215003755597344 + }, + { + "step": 547, + "lr": 0.0001, + "sup_loss": 2.215045465461095 + }, + { + "step": 548, + "lr": 0.0001, + "sup_loss": 2.2151899471725573 + }, + { + "step": 549, + "lr": 0.0001, + "sup_loss": 2.214607852524012 + }, + { + "step": 550, + "lr": 0.0001, + "sup_loss": 2.2146216899108984 + }, + { + "step": 551, + "lr": 0.0001, + "sup_loss": 2.2147443852251607 + }, + { + "step": 552, + "lr": 0.0001, + "sup_loss": 2.214751357815832 + }, + { + "step": 553, + "lr": 0.0001, + "sup_loss": 2.2142929980741966 + }, + { + "step": 554, + "lr": 0.0001, + "sup_loss": 2.214279741652014 + }, + { + "step": 555, + "lr": 0.0001, + "sup_loss": 2.214378452674666 + }, + { + "step": 556, + "lr": 0.0001, + "sup_loss": 2.2142724060090897 + }, + { + "step": 557, + "lr": 0.0001, + "sup_loss": 2.2139154490811817 + }, + { + "step": 558, + "lr": 0.0001, + "sup_loss": 2.2142828378283586 + }, + { + "step": 559, + "lr": 0.0001, + "sup_loss": 2.21367427009076 + }, + { + "step": 560, + "lr": 0.0001, + "sup_loss": 2.213750007367428 + }, + { + "step": 561, + "lr": 0.0001, + "sup_loss": 2.2139930013059765 + }, + { + "step": 562, + "lr": 0.0001, + "sup_loss": 2.2139212528714936 + }, + { + "step": 563, + "lr": 0.0001, + "sup_loss": 2.213718407455631 + }, + { + "step": 564, + "lr": 0.0001, + "sup_loss": 2.213884944699152 + }, + { + "step": 565, + "lr": 0.0001, + "sup_loss": 2.21344836987307 + }, + { + "step": 566, + "lr": 0.0001, + "sup_loss": 2.213384656437 + }, + { + "step": 567, + "lr": 0.0001, + "sup_loss": 2.213334960690562 + }, + { + "step": 568, + "lr": 0.0001, + "sup_loss": 2.213357478868861 + }, + { + "step": 569, + "lr": 0.0001, + "sup_loss": 2.2130341515927725 + }, + { + "step": 570, + "lr": 0.0001, + "sup_loss": 2.2136387339570978 + }, + { + "step": 571, + "lr": 0.0001, + "sup_loss": 2.2134530105706234 + }, + { + "step": 572, + "lr": 0.0001, + "sup_loss": 2.2136570237406508 + }, + { + "step": 573, + "lr": 0.0001, + "sup_loss": 2.2133583624083135 + }, + { + "step": 574, + "lr": 0.0001, + "sup_loss": 2.2139012892336147 + }, + { + "step": 575, + "lr": 0.0001, + "sup_loss": 2.213892438328747 + }, + { + "step": 576, + "lr": 0.0001, + "sup_loss": 2.2134513094834904 + }, + { + "step": 577, + "lr": 0.0001, + "sup_loss": 2.2133618012075464 + }, + { + "step": 578, + "lr": 0.0001, + "sup_loss": 2.213437561287246 + }, + { + "step": 579, + "lr": 0.0001, + "sup_loss": 2.213234446505955 + }, + { + "step": 580, + "lr": 0.0001, + "sup_loss": 2.212818212889607 + }, + { + "step": 581, + "lr": 0.0001, + "sup_loss": 2.213058733016367 + }, + { + "step": 582, + "lr": 0.0001, + "sup_loss": 2.2128706739762016 + }, + { + "step": 583, + "lr": 0.0001, + "sup_loss": 2.2128812463201664 + }, + { + "step": 584, + "lr": 0.0001, + "sup_loss": 2.2127904829468106 + }, + { + "step": 585, + "lr": 0.0001, + "sup_loss": 2.2128529205240524 + }, + { + "step": 586, + "lr": 0.0001, + "sup_loss": 2.2124409476905402 + }, + { + "step": 587, + "lr": 0.0001, + "sup_loss": 2.2129027973367497 + }, + { + "step": 588, + "lr": 0.0001, + "sup_loss": 2.212514324759956 + }, + { + "step": 589, + "lr": 0.0001, + "sup_loss": 2.212624633748884 + }, + { + "step": 590, + "lr": 0.0001, + "sup_loss": 2.2121483079982096 + }, + { + "step": 591, + "lr": 0.0001, + "sup_loss": 2.2122220714722522 + }, + { + "step": 592, + "lr": 0.0001, + "sup_loss": 2.2125799650934974 + }, + { + "step": 593, + "lr": 0.0001, + "sup_loss": 2.2122990594944523 + }, + { + "step": 594, + "lr": 0.0001, + "sup_loss": 2.2121141378031357 + }, + { + "step": 595, + "lr": 0.0001, + "sup_loss": 2.212132478553787 + }, + { + "step": 596, + "lr": 0.0001, + "sup_loss": 2.2119692848725423 + }, + { + "step": 597, + "lr": 0.0001, + "sup_loss": 2.2120347851304247 + }, + { + "step": 598, + "lr": 0.0001, + "sup_loss": 2.2118640568300387 + }, + { + "step": 599, + "lr": 0.0001, + "sup_loss": 2.211811494562072 + }, + { + "step": 600, + "lr": 0.0001, + "sup_loss": 2.212073144464957 + }, + { + "step": 601, + "lr": 0.0001, + "sup_loss": 2.2115798014867027 + }, + { + "step": 602, + "lr": 0.0001, + "sup_loss": 2.2115814718262046 + }, + { + "step": 603, + "lr": 0.0001, + "sup_loss": 2.2114946236056974 + }, + { + "step": 604, + "lr": 0.0001, + "sup_loss": 2.211491638669447 + }, + { + "step": 605, + "lr": 0.0001, + "sup_loss": 2.2111605024374787 + }, + { + "step": 606, + "lr": 0.0001, + "sup_loss": 2.211257511296512 + }, + { + "step": 607, + "lr": 0.0001, + "sup_loss": 2.211227577447096 + }, + { + "step": 608, + "lr": 0.0001, + "sup_loss": 2.211044364249239 + }, + { + "step": 609, + "lr": 0.0001, + "sup_loss": 2.2109505811411583 + }, + { + "step": 610, + "lr": 0.0001, + "sup_loss": 2.2109054175438745 + }, + { + "step": 611, + "lr": 0.0001, + "sup_loss": 2.2109989162634904 + }, + { + "step": 612, + "lr": 0.0001, + "sup_loss": 2.210910730428145 + }, + { + "step": 613, + "lr": 0.0001, + "sup_loss": 2.211159904926039 + }, + { + "step": 614, + "lr": 0.0001, + "sup_loss": 2.2108575436478626 + }, + { + "step": 615, + "lr": 0.0001, + "sup_loss": 2.210819174305394 + }, + { + "step": 616, + "lr": 0.0001, + "sup_loss": 2.2109998014501713 + }, + { + "step": 617, + "lr": 0.0001, + "sup_loss": 2.2106426187175066 + }, + { + "step": 618, + "lr": 0.0001, + "sup_loss": 2.2104796302308793 + }, + { + "step": 619, + "lr": 0.0001, + "sup_loss": 2.2105721926821413 + }, + { + "step": 620, + "lr": 0.0001, + "sup_loss": 2.210259936169861 + }, + { + "step": 621, + "lr": 0.0001, + "sup_loss": 2.2101677994108235 + }, + { + "step": 622, + "lr": 0.0001, + "sup_loss": 2.2102742170917713 + }, + { + "step": 623, + "lr": 0.0001, + "sup_loss": 2.209962769104158 + }, + { + "step": 624, + "lr": 0.0001, + "sup_loss": 2.2105286410768166 + }, + { + "step": 625, + "lr": 0.0001, + "sup_loss": 2.209717205608196 + }, + { + "step": 626, + "lr": 0.0001, + "sup_loss": 2.209944645576004 + }, + { + "step": 627, + "lr": 0.0001, + "sup_loss": 2.2096266948592276 + }, + { + "step": 628, + "lr": 0.0001, + "sup_loss": 2.2098513137700273 + }, + { + "step": 629, + "lr": 0.0001, + "sup_loss": 2.209724173618599 + }, + { + "step": 630, + "lr": 0.0001, + "sup_loss": 2.20949332428615 + }, + { + "step": 631, + "lr": 0.0001, + "sup_loss": 2.2093630609809893 + }, + { + "step": 632, + "lr": 0.0001, + "sup_loss": 2.209439405903672 + }, + { + "step": 633, + "lr": 0.0001, + "sup_loss": 2.2093093430907618 + }, + { + "step": 634, + "lr": 0.0001, + "sup_loss": 2.209571682852405 + }, + { + "step": 635, + "lr": 0.0001, + "sup_loss": 2.2094045765079726 + }, + { + "step": 636, + "lr": 0.0001, + "sup_loss": 2.2093758578813056 + }, + { + "step": 637, + "lr": 0.0001, + "sup_loss": 2.2093137931755873 + }, + { + "step": 638, + "lr": 0.0001, + "sup_loss": 2.209234466271327 + }, + { + "step": 639, + "lr": 0.0001, + "sup_loss": 2.2091465674727986 + }, + { + "step": 640, + "lr": 0.0001, + "sup_loss": 2.2090962600002575 + }, + { + "step": 641, + "lr": 0.0001, + "sup_loss": 2.208922047590961 + }, + { + "step": 642, + "lr": 0.0001, + "sup_loss": 2.2087714186708096 + }, + { + "step": 643, + "lr": 0.0001, + "sup_loss": 2.208743637452737 + }, + { + "step": 644, + "lr": 0.0001, + "sup_loss": 2.2087570850990774 + }, + { + "step": 645, + "lr": 0.0001, + "sup_loss": 2.2086549452749913 + }, + { + "step": 646, + "lr": 0.0001, + "sup_loss": 2.2086531652176826 + }, + { + "step": 647, + "lr": 0.0001, + "sup_loss": 2.208676198420254 + }, + { + "step": 648, + "lr": 0.0001, + "sup_loss": 2.208586722104768 + }, + { + "step": 649, + "lr": 0.0001, + "sup_loss": 2.2087718747003935 + }, + { + "step": 650, + "lr": 0.0001, + "sup_loss": 2.2085029958135984 + }, + { + "step": 651, + "lr": 0.0001, + "sup_loss": 2.208436265187175 + }, + { + "step": 652, + "lr": 0.0001, + "sup_loss": 2.2083608807120387 + }, + { + "step": 653, + "lr": 0.0001, + "sup_loss": 2.2081720972313263 + }, + { + "step": 654, + "lr": 0.0001, + "sup_loss": 2.208153973917292 + }, + { + "step": 655, + "lr": 0.0001, + "sup_loss": 2.2080094278856013 + }, + { + "step": 656, + "lr": 0.0001, + "sup_loss": 2.2078942890846904 + }, + { + "step": 657, + "lr": 0.0001, + "sup_loss": 2.2079961959942387 + }, + { + "step": 658, + "lr": 0.0001, + "sup_loss": 2.208016902399448 + }, + { + "step": 659, + "lr": 0.0001, + "sup_loss": 2.207716681997382 + }, + { + "step": 660, + "lr": 0.0001, + "sup_loss": 2.207815803827112 + }, + { + "step": 661, + "lr": 0.0001, + "sup_loss": 2.2075420948408495 + }, + { + "step": 662, + "lr": 0.0001, + "sup_loss": 2.2075951575855752 + }, + { + "step": 663, + "lr": 0.0001, + "sup_loss": 2.207502053507793 + }, + { + "step": 664, + "lr": 0.0001, + "sup_loss": 2.207455952282843 + }, + { + "step": 665, + "lr": 0.0001, + "sup_loss": 2.2074879627651534 + }, + { + "step": 666, + "lr": 0.0001, + "sup_loss": 2.207499467996968 + }, + { + "step": 667, + "lr": 0.0001, + "sup_loss": 2.2074814185516054 + }, + { + "step": 668, + "lr": 0.0001, + "sup_loss": 2.2073871159465916 + }, + { + "step": 669, + "lr": 0.0001, + "sup_loss": 2.2073787846493045 + }, + { + "step": 670, + "lr": 0.0001, + "sup_loss": 2.2074647655230666 + }, + { + "step": 671, + "lr": 0.0001, + "sup_loss": 2.20733957464375 + }, + { + "step": 672, + "lr": 0.0001, + "sup_loss": 2.207198658180965 + }, + { + "step": 673, + "lr": 0.0001, + "sup_loss": 2.207214682124266 + }, + { + "step": 674, + "lr": 0.0001, + "sup_loss": 2.2071675725631943 + }, + { + "step": 675, + "lr": 0.0001, + "sup_loss": 2.2073198798156137 + }, + { + "step": 676, + "lr": 0.0001, + "sup_loss": 2.206930591829342 + }, + { + "step": 677, + "lr": 0.0001, + "sup_loss": 2.2069973605926028 + }, + { + "step": 678, + "lr": 0.0001, + "sup_loss": 2.2069061353529307 + }, + { + "step": 679, + "lr": 0.0001, + "sup_loss": 2.2067484682728304 + }, + { + "step": 680, + "lr": 0.0001, + "sup_loss": 2.2069449516816175 + }, + { + "step": 681, + "lr": 0.0001, + "sup_loss": 2.206805213007498 + }, + { + "step": 682, + "lr": 0.0001, + "sup_loss": 2.2066835527849653 + }, + { + "step": 683, + "lr": 0.0001, + "sup_loss": 2.2066421136204326 + }, + { + "step": 684, + "lr": 0.0001, + "sup_loss": 2.206570933122996 + }, + { + "step": 685, + "lr": 0.0001, + "sup_loss": 2.206645964698992 + }, + { + "step": 686, + "lr": 0.0001, + "sup_loss": 2.2066180639591453 + }, + { + "step": 687, + "lr": 0.0001, + "sup_loss": 2.206407486611538 + }, + { + "step": 688, + "lr": 0.0001, + "sup_loss": 2.2065140964419565 + }, + { + "step": 689, + "lr": 0.0001, + "sup_loss": 2.206673174032117 + }, + { + "step": 690, + "lr": 0.0001, + "sup_loss": 2.206480749890056 + }, + { + "step": 691, + "lr": 0.0001, + "sup_loss": 2.2063547848714404 + }, + { + "step": 692, + "lr": 0.0001, + "sup_loss": 2.2063683160649346 + }, + { + "step": 693, + "lr": 0.0001, + "sup_loss": 2.206358540222222 + }, + { + "step": 694, + "lr": 0.0001, + "sup_loss": 2.206300256957832 + }, + { + "step": 695, + "lr": 0.0001, + "sup_loss": 2.206184195497584 + }, + { + "step": 696, + "lr": 0.0001, + "sup_loss": 2.2061660633772138 + }, + { + "step": 697, + "lr": 0.0001, + "sup_loss": 2.206177625761696 + }, + { + "step": 698, + "lr": 0.0001, + "sup_loss": 2.20620451254569 + }, + { + "step": 699, + "lr": 0.0001, + "sup_loss": 2.20630181141729 + }, + { + "step": 700, + "lr": 0.0001, + "sup_loss": 2.2062036858623157 + }, + { + "step": 701, + "lr": 0.0001, + "sup_loss": 2.2063594978738266 + }, + { + "step": 702, + "lr": 0.0001, + "sup_loss": 2.206361189182089 + }, + { + "step": 703, + "lr": 0.0001, + "sup_loss": 2.2063975496430324 + }, + { + "step": 704, + "lr": 0.0001, + "sup_loss": 2.2063436318989478 + }, + { + "step": 705, + "lr": 0.0001, + "sup_loss": 2.206236367501852 + }, + { + "step": 706, + "lr": 0.0001, + "sup_loss": 2.2062831504499987 + }, + { + "step": 707, + "lr": 0.0001, + "sup_loss": 2.206423416738055 + }, + { + "step": 708, + "lr": 0.0001, + "sup_loss": 2.2061095114216562 + }, + { + "step": 709, + "lr": 0.0001, + "sup_loss": 2.206041806201691 + }, + { + "step": 710, + "lr": 0.0001, + "sup_loss": 2.2060407458541094 + }, + { + "step": 711, + "lr": 0.0001, + "sup_loss": 2.2060146509126852 + }, + { + "step": 712, + "lr": 0.0001, + "sup_loss": 2.2060991926019193 + }, + { + "step": 713, + "lr": 0.0001, + "sup_loss": 2.2061511805461773 + }, + { + "step": 714, + "lr": 0.0001, + "sup_loss": 2.20598059097607 + }, + { + "step": 715, + "lr": 0.0001, + "sup_loss": 2.205897772483963 + }, + { + "step": 716, + "lr": 0.0001, + "sup_loss": 2.20568588428355 + }, + { + "step": 717, + "lr": 0.0001, + "sup_loss": 2.205900667087804 + }, + { + "step": 718, + "lr": 0.0001, + "sup_loss": 2.2057657470591883 + }, + { + "step": 719, + "lr": 0.0001, + "sup_loss": 2.2058253937840653 + }, + { + "step": 720, + "lr": 0.0001, + "sup_loss": 2.2056522560318523 + }, + { + "step": 721, + "lr": 0.0001, + "sup_loss": 2.2056988860558358 + }, + { + "step": 722, + "lr": 0.0001, + "sup_loss": 2.205514144195623 + }, + { + "step": 723, + "lr": 0.0001, + "sup_loss": 2.2054512806390227 + }, + { + "step": 724, + "lr": 0.0001, + "sup_loss": 2.20539748717649 + }, + { + "step": 725, + "lr": 0.0001, + "sup_loss": 2.2056278548444292 + }, + { + "step": 726, + "lr": 0.0001, + "sup_loss": 2.2055334173132235 + }, + { + "step": 727, + "lr": 0.0001, + "sup_loss": 2.205504980341082 + }, + { + "step": 728, + "lr": 0.0001, + "sup_loss": 2.205365376027528 + }, + { + "step": 729, + "lr": 0.0001, + "sup_loss": 2.205391515936735 + }, + { + "step": 730, + "lr": 0.0001, + "sup_loss": 2.2053113576978483 + }, + { + "step": 731, + "lr": 0.0001, + "sup_loss": 2.20518392993963 + }, + { + "step": 732, + "lr": 0.0001, + "sup_loss": 2.2053675105234976 + }, + { + "step": 733, + "lr": 0.0001, + "sup_loss": 2.205109080592016 + }, + { + "step": 734, + "lr": 0.0001, + "sup_loss": 2.205071932257977 + }, + { + "step": 735, + "lr": 0.0001, + "sup_loss": 2.2051178059146697 + }, + { + "step": 736, + "lr": 0.0001, + "sup_loss": 2.205151026656475 + }, + { + "step": 737, + "lr": 0.0001, + "sup_loss": 2.2049395257945794 + }, + { + "step": 738, + "lr": 0.0001, + "sup_loss": 2.2050165699732336 + }, + { + "step": 739, + "lr": 0.0001, + "sup_loss": 2.204972621616195 + }, + { + "step": 740, + "lr": 0.0001, + "sup_loss": 2.2049895211853454 + }, + { + "step": 741, + "lr": 0.0001, + "sup_loss": 2.205033422128048 + }, + { + "step": 742, + "lr": 0.0001, + "sup_loss": 2.2048935092943096 + }, + { + "step": 743, + "lr": 0.0001, + "sup_loss": 2.204962253885092 + }, + { + "step": 744, + "lr": 0.0001, + "sup_loss": 2.204913877952223 + }, + { + "step": 745, + "lr": 0.0001, + "sup_loss": 2.2048299441495387 + }, + { + "step": 746, + "lr": 0.0001, + "sup_loss": 2.204818615402629 + }, + { + "step": 747, + "lr": 0.0001, + "sup_loss": 2.2047841077562866 + }, + { + "step": 748, + "lr": 0.0001, + "sup_loss": 2.204669452542029 + }, + { + "step": 749, + "lr": 0.0001, + "sup_loss": 2.20465382700599 + }, + { + "step": 750, + "lr": 0.0001, + "sup_loss": 2.20451853876805 + }, + { + "step": 751, + "lr": 0.0001, + "sup_loss": 2.2044825295715764 + }, + { + "step": 752, + "lr": 0.0001, + "sup_loss": 2.204418766475017 + }, + { + "step": 753, + "lr": 0.0001, + "sup_loss": 2.204414998567867 + }, + { + "step": 754, + "lr": 0.0001, + "sup_loss": 2.204372410925386 + }, + { + "step": 755, + "lr": 0.0001, + "sup_loss": 2.2044409029992296 + }, + { + "step": 756, + "lr": 0.0001, + "sup_loss": 2.2043787499322747 + }, + { + "step": 757, + "lr": 0.0001, + "sup_loss": 2.2044183904116155 + }, + { + "step": 758, + "lr": 0.0001, + "sup_loss": 2.204396420392982 + }, + { + "step": 759, + "lr": 0.0001, + "sup_loss": 2.2042665666197436 + }, + { + "step": 760, + "lr": 0.0001, + "sup_loss": 2.2042017188269227 + }, + { + "step": 761, + "lr": 0.0001, + "sup_loss": 2.2042056202612823 + }, + { + "step": 762, + "lr": 0.0001, + "sup_loss": 2.2041625816044315 + }, + { + "step": 763, + "lr": 0.0001, + "sup_loss": 2.2041097718238674 + }, + { + "step": 764, + "lr": 0.0001, + "sup_loss": 2.2040353422848735 + }, + { + "step": 765, + "lr": 0.0001, + "sup_loss": 2.2040090906432397 + }, + { + "step": 766, + "lr": 0.0001, + "sup_loss": 2.2039352896245354 + }, + { + "step": 767, + "lr": 0.0001, + "sup_loss": 2.2041224540834357 + }, + { + "step": 768, + "lr": 0.0001, + "sup_loss": 2.204047855573587 + }, + { + "step": 769, + "lr": 0.0001, + "sup_loss": 2.2039772370477326 + }, + { + "step": 770, + "lr": 0.0001, + "sup_loss": 2.2039730454595223 + }, + { + "step": 771, + "lr": 0.0001, + "sup_loss": 2.2039397869821804 + }, + { + "step": 772, + "lr": 0.0001, + "sup_loss": 2.2039334200894283 + }, + { + "step": 773, + "lr": 0.0001, + "sup_loss": 2.2038314653506292 + }, + { + "step": 774, + "lr": 0.0001, + "sup_loss": 2.2037494425475948 + }, + { + "step": 775, + "lr": 0.0001, + "sup_loss": 2.203829158518422 + }, + { + "step": 776, + "lr": 0.0001, + "sup_loss": 2.20368516005549 + }, + { + "step": 777, + "lr": 0.0001, + "sup_loss": 2.2036277181256794 + }, + { + "step": 778, + "lr": 0.0001, + "sup_loss": 2.2036412910172487 + }, + { + "step": 779, + "lr": 0.0001, + "sup_loss": 2.20369948246613 + }, + { + "step": 780, + "lr": 0.0001, + "sup_loss": 2.2034654903784516 + }, + { + "step": 781, + "lr": 0.0001, + "sup_loss": 2.2036322054376423 + }, + { + "step": 782, + "lr": 0.0001, + "sup_loss": 2.2034864184518095 + }, + { + "step": 783, + "lr": 0.0001, + "sup_loss": 2.2034823762248905 + }, + { + "step": 784, + "lr": 0.0001, + "sup_loss": 2.203334152731814 + }, + { + "step": 785, + "lr": 0.0001, + "sup_loss": 2.203367400549507 + }, + { + "step": 786, + "lr": 0.0001, + "sup_loss": 2.203323176066359 + }, + { + "step": 787, + "lr": 0.0001, + "sup_loss": 2.2033690610123684 + }, + { + "step": 788, + "lr": 0.0001, + "sup_loss": 2.2032841185354037 + }, + { + "step": 789, + "lr": 0.0001, + "sup_loss": 2.203248450769099 + }, + { + "step": 790, + "lr": 0.0001, + "sup_loss": 2.203449022669672 + }, + { + "step": 791, + "lr": 0.0001, + "sup_loss": 2.203175502023462 + }, + { + "step": 792, + "lr": 0.0001, + "sup_loss": 2.2030761005092763 + }, + { + "step": 793, + "lr": 0.0001, + "sup_loss": 2.2031189312503465 + }, + { + "step": 794, + "lr": 0.0001, + "sup_loss": 2.203103587411937 + }, + { + "step": 795, + "lr": 0.0001, + "sup_loss": 2.2031392935374727 + }, + { + "step": 796, + "lr": 0.0001, + "sup_loss": 2.2030956770235504 + }, + { + "step": 797, + "lr": 0.0001, + "sup_loss": 2.203161065642516 + }, + { + "step": 798, + "lr": 0.0001, + "sup_loss": 2.2030714194373218 + }, + { + "step": 799, + "lr": 0.0001, + "sup_loss": 2.2029618359068217 + }, + { + "step": 800, + "lr": 0.0001, + "sup_loss": 2.202936070527028 + }, + { + "step": 801, + "lr": 0.0001, + "sup_loss": 2.2030515435763376 + }, + { + "step": 802, + "lr": 0.0001, + "sup_loss": 2.20294922690391 + }, + { + "step": 803, + "lr": 0.0001, + "sup_loss": 2.2028913815030333 + }, + { + "step": 804, + "lr": 0.0001, + "sup_loss": 2.2028682891051146 + }, + { + "step": 805, + "lr": 0.0001, + "sup_loss": 2.2027819903948043 + }, + { + "step": 806, + "lr": 0.0001, + "sup_loss": 2.202785788260016 + }, + { + "step": 807, + "lr": 0.0001, + "sup_loss": 2.2027684573267043 + }, + { + "step": 808, + "lr": 0.0001, + "sup_loss": 2.202839287509012 + }, + { + "step": 809, + "lr": 0.0001, + "sup_loss": 2.202736708275241 + }, + { + "step": 810, + "lr": 0.0001, + "sup_loss": 2.202919625343286 + }, + { + "step": 811, + "lr": 0.0001, + "sup_loss": 2.2027683192415055 + }, + { + "step": 812, + "lr": 0.0001, + "sup_loss": 2.2026705694376396 + }, + { + "step": 813, + "lr": 0.0001, + "sup_loss": 2.202639741289174 + }, + { + "step": 814, + "lr": 0.0001, + "sup_loss": 2.202578109726076 + }, + { + "step": 815, + "lr": 0.0001, + "sup_loss": 2.202548109200643 + }, + { + "step": 816, + "lr": 0.0001, + "sup_loss": 2.2026844218939456 + }, + { + "step": 817, + "lr": 0.0001, + "sup_loss": 2.202621651152489 + }, + { + "step": 818, + "lr": 0.0001, + "sup_loss": 2.2026209744654954 + }, + { + "step": 819, + "lr": 0.0001, + "sup_loss": 2.202534758687879 + }, + { + "step": 820, + "lr": 0.0001, + "sup_loss": 2.202476671015975 + }, + { + "step": 821, + "lr": 0.0001, + "sup_loss": 2.202494463153179 + }, + { + "step": 822, + "lr": 0.0001, + "sup_loss": 2.202541489167438 + }, + { + "step": 823, + "lr": 0.0001, + "sup_loss": 2.2025388581017444 + }, + { + "step": 824, + "lr": 0.0001, + "sup_loss": 2.202456550918718 + }, + { + "step": 825, + "lr": 0.0001, + "sup_loss": 2.2025445029149844 + }, + { + "step": 826, + "lr": 0.0001, + "sup_loss": 2.202565498789714 + }, + { + "step": 827, + "lr": 0.0001, + "sup_loss": 2.202714185960078 + }, + { + "step": 828, + "lr": 0.0001, + "sup_loss": 2.202701346744241 + }, + { + "step": 829, + "lr": 0.0001, + "sup_loss": 2.202658298140033 + }, + { + "step": 830, + "lr": 0.0001, + "sup_loss": 2.2026088333741827 + }, + { + "step": 831, + "lr": 0.0001, + "sup_loss": 2.2025971991722795 + }, + { + "step": 832, + "lr": 0.0001, + "sup_loss": 2.2025936742942176 + }, + { + "step": 833, + "lr": 0.0001, + "sup_loss": 2.2026309167286957 + }, + { + "step": 834, + "lr": 0.0001, + "sup_loss": 2.2025391090671107 + }, + { + "step": 835, + "lr": 0.0001, + "sup_loss": 2.202519772751267 + }, + { + "step": 836, + "lr": 0.0001, + "sup_loss": 2.20250093997264 + }, + { + "step": 837, + "lr": 0.0001, + "sup_loss": 2.2024548457335085 + }, + { + "step": 838, + "lr": 0.0001, + "sup_loss": 2.2024518334249374 + }, + { + "step": 839, + "lr": 0.0001, + "sup_loss": 2.2024767466770507 + }, + { + "step": 840, + "lr": 0.0001, + "sup_loss": 2.202545036291272 + }, + { + "step": 841, + "lr": 0.0001, + "sup_loss": 2.202420629815392 + }, + { + "step": 842, + "lr": 0.0001, + "sup_loss": 2.2023156240380626 + }, + { + "step": 843, + "lr": 0.0001, + "sup_loss": 2.2022990286026807 + }, + { + "step": 844, + "lr": 0.0001, + "sup_loss": 2.2023455979736095 + }, + { + "step": 845, + "lr": 0.0001, + "sup_loss": 2.2023758604300774 + }, + { + "step": 846, + "lr": 0.0001, + "sup_loss": 2.2023779436605726 + }, + { + "step": 847, + "lr": 0.0001, + "sup_loss": 2.202409370319007 + }, + { + "step": 848, + "lr": 0.0001, + "sup_loss": 2.202314650109519 + }, + { + "step": 849, + "lr": 0.0001, + "sup_loss": 2.202228380824696 + }, + { + "step": 850, + "lr": 0.0001, + "sup_loss": 2.20215610730638 + }, + { + "step": 851, + "lr": 0.0001, + "sup_loss": 2.202290271210492 + }, + { + "step": 852, + "lr": 0.0001, + "sup_loss": 2.202270951137616 + }, + { + "step": 853, + "lr": 0.0001, + "sup_loss": 2.202346530579742 + }, + { + "step": 854, + "lr": 0.0001, + "sup_loss": 2.2021673619619513 + }, + { + "step": 855, + "lr": 0.0001, + "sup_loss": 2.202128879483182 + }, + { + "step": 856, + "lr": 0.0001, + "sup_loss": 2.202179063401366 + }, + { + "step": 857, + "lr": 0.0001, + "sup_loss": 2.2020229116359786 + }, + { + "step": 858, + "lr": 0.0001, + "sup_loss": 2.202012275964508 + }, + { + "step": 859, + "lr": 0.0001, + "sup_loss": 2.202010752428174 + }, + { + "step": 860, + "lr": 0.0001, + "sup_loss": 2.2020523902238542 + }, + { + "step": 861, + "lr": 0.0001, + "sup_loss": 2.202006333836611 + }, + { + "step": 862, + "lr": 0.0001, + "sup_loss": 2.201912427261241 + }, + { + "step": 863, + "lr": 0.0001, + "sup_loss": 2.2019475411438236 + }, + { + "step": 864, + "lr": 0.0001, + "sup_loss": 2.201883399778625 + }, + { + "step": 865, + "lr": 0.0001, + "sup_loss": 2.2020025364368148 + }, + { + "step": 866, + "lr": 0.0001, + "sup_loss": 2.2019285312099295 + }, + { + "step": 867, + "lr": 0.0001, + "sup_loss": 2.201999130227664 + }, + { + "step": 868, + "lr": 0.0001, + "sup_loss": 2.20188716050076 + }, + { + "step": 869, + "lr": 0.0001, + "sup_loss": 2.2018200891073167 + }, + { + "step": 870, + "lr": 0.0001, + "sup_loss": 2.2018589975711214 + }, + { + "step": 871, + "lr": 0.0001, + "sup_loss": 2.201799591961473 + }, + { + "step": 872, + "lr": 0.0001, + "sup_loss": 2.201851977800925 + }, + { + "step": 873, + "lr": 0.0001, + "sup_loss": 2.201768283932313 + }, + { + "step": 874, + "lr": 0.0001, + "sup_loss": 2.201655822757606 + }, + { + "step": 875, + "lr": 0.0001, + "sup_loss": 2.2017120812775106 + }, + { + "step": 876, + "lr": 0.0001, + "sup_loss": 2.2016763220143636 + }, + { + "step": 877, + "lr": 0.0001, + "sup_loss": 2.201622727767427 + }, + { + "step": 878, + "lr": 0.0001, + "sup_loss": 2.201587625745363 + }, + { + "step": 879, + "lr": 0.0001, + "sup_loss": 2.201508552855647 + }, + { + "step": 880, + "lr": 0.0001, + "sup_loss": 2.201559174708979 + }, + { + "step": 881, + "lr": 0.0001, + "sup_loss": 2.201569206056897 + }, + { + "step": 882, + "lr": 0.0001, + "sup_loss": 2.2016111795010658 + }, + { + "step": 883, + "lr": 0.0001, + "sup_loss": 2.2015496523036377 + }, + { + "step": 884, + "lr": 0.0001, + "sup_loss": 2.2015549056980253 + }, + { + "step": 885, + "lr": 0.0001, + "sup_loss": 2.201537625295753 + }, + { + "step": 886, + "lr": 0.0001, + "sup_loss": 2.2014597771881426 + }, + { + "step": 887, + "lr": 0.0001, + "sup_loss": 2.201466935643165 + }, + { + "step": 888, + "lr": 0.0001, + "sup_loss": 2.201458056595927 + }, + { + "step": 889, + "lr": 0.0001, + "sup_loss": 2.2014423772243195 + }, + { + "step": 890, + "lr": 0.0001, + "sup_loss": 2.2014001553686904 + }, + { + "step": 891, + "lr": 0.0001, + "sup_loss": 2.201386916752708 + }, + { + "step": 892, + "lr": 0.0001, + "sup_loss": 2.201379603326555 + }, + { + "step": 893, + "lr": 0.0001, + "sup_loss": 2.201388145594879 + }, + { + "step": 894, + "lr": 0.0001, + "sup_loss": 2.2013790017726564 + }, + { + "step": 895, + "lr": 0.0001, + "sup_loss": 2.2014738717540365 + }, + { + "step": 896, + "lr": 0.0001, + "sup_loss": 2.2013619829248285 + }, + { + "step": 897, + "lr": 0.0001, + "sup_loss": 2.2013757452435065 + }, + { + "step": 898, + "lr": 0.0001, + "sup_loss": 2.2012969495965318 + }, + { + "step": 899, + "lr": 0.0001, + "sup_loss": 2.2012578711136133 + }, + { + "step": 900, + "lr": 0.0001, + "sup_loss": 2.2013008031481047 + }, + { + "step": 901, + "lr": 0.0001, + "sup_loss": 2.20127758890747 + }, + { + "step": 902, + "lr": 0.0001, + "sup_loss": 2.2012622915507776 + }, + { + "step": 903, + "lr": 0.0001, + "sup_loss": 2.201282180610047 + }, + { + "step": 904, + "lr": 0.0001, + "sup_loss": 2.2011898042593163 + }, + { + "step": 905, + "lr": 0.0001, + "sup_loss": 2.201114980652287 + }, + { + "step": 906, + "lr": 0.0001, + "sup_loss": 2.2010839388761654 + }, + { + "step": 907, + "lr": 0.0001, + "sup_loss": 2.2011066260231225 + }, + { + "step": 908, + "lr": 0.0001, + "sup_loss": 2.201111908179561 + }, + { + "step": 909, + "lr": 0.0001, + "sup_loss": 2.2010809698970335 + }, + { + "step": 910, + "lr": 0.0001, + "sup_loss": 2.2010995449035766 + }, + { + "step": 911, + "lr": 0.0001, + "sup_loss": 2.2010552392935954 + }, + { + "step": 912, + "lr": 0.0001, + "sup_loss": 2.201029023825253 + }, + { + "step": 913, + "lr": 0.0001, + "sup_loss": 2.200943471892004 + }, + { + "step": 914, + "lr": 0.0001, + "sup_loss": 2.200980833896399 + }, + { + "step": 915, + "lr": 0.0001, + "sup_loss": 2.2010700456810537 + }, + { + "step": 916, + "lr": 0.0001, + "sup_loss": 2.200896622835691 + }, + { + "step": 917, + "lr": 0.0001, + "sup_loss": 2.200987347007047 + }, + { + "step": 918, + "lr": 0.0001, + "sup_loss": 2.200882012650334 + }, + { + "step": 919, + "lr": 0.0001, + "sup_loss": 2.2008894594455137 + }, + { + "step": 920, + "lr": 0.0001, + "sup_loss": 2.200906012994198 + }, + { + "step": 921, + "lr": 0.0001, + "sup_loss": 2.2008042736527313 + }, + { + "step": 922, + "lr": 0.0001, + "sup_loss": 2.200886573334916 + }, + { + "step": 923, + "lr": 0.0001, + "sup_loss": 2.200890599674092 + }, + { + "step": 924, + "lr": 0.0001, + "sup_loss": 2.200866394128699 + }, + { + "step": 925, + "lr": 0.0001, + "sup_loss": 2.200889150378319 + }, + { + "step": 926, + "lr": 0.0001, + "sup_loss": 2.200822478600595 + }, + { + "step": 927, + "lr": 0.0001, + "sup_loss": 2.200872497048016 + }, + { + "step": 928, + "lr": 0.0001, + "sup_loss": 2.2007486366339144 + }, + { + "step": 929, + "lr": 0.0001, + "sup_loss": 2.2008072049273233 + }, + { + "step": 930, + "lr": 0.0001, + "sup_loss": 2.200714092098603 + }, + { + "step": 931, + "lr": 0.0001, + "sup_loss": 2.2006938546821018 + }, + { + "step": 932, + "lr": 0.0001, + "sup_loss": 2.2006972820938815 + }, + { + "step": 933, + "lr": 0.0001, + "sup_loss": 2.2006833207079888 + }, + { + "step": 934, + "lr": 0.0001, + "sup_loss": 2.2006629617376965 + }, + { + "step": 935, + "lr": 0.0001, + "sup_loss": 2.2006923370790727 + }, + { + "step": 936, + "lr": 0.0001, + "sup_loss": 2.2007020493686986 + }, + { + "step": 937, + "lr": 0.0001, + "sup_loss": 2.200661542319699 + }, + { + "step": 938, + "lr": 0.0001, + "sup_loss": 2.2007424345051425 + }, + { + "step": 939, + "lr": 0.0001, + "sup_loss": 2.2006466485351357 + }, + { + "step": 940, + "lr": 0.0001, + "sup_loss": 2.200640985444488 + }, + { + "step": 941, + "lr": 0.0001, + "sup_loss": 2.2006154396446402 + }, + { + "step": 942, + "lr": 0.0001, + "sup_loss": 2.200622252949636 + }, + { + "step": 943, + "lr": 0.0001, + "sup_loss": 2.2005978503372026 + }, + { + "step": 944, + "lr": 0.0001, + "sup_loss": 2.200589127181636 + }, + { + "step": 945, + "lr": 0.0001, + "sup_loss": 2.2005873948735655 + }, + { + "step": 946, + "lr": 0.0001, + "sup_loss": 2.2006292234524105 + }, + { + "step": 947, + "lr": 0.0001, + "sup_loss": 2.2005128505364837 + }, + { + "step": 948, + "lr": 0.0001, + "sup_loss": 2.2004986638021093 + }, + { + "step": 949, + "lr": 0.0001, + "sup_loss": 2.200523243338396 + }, + { + "step": 950, + "lr": 0.0001, + "sup_loss": 2.200578262432583 + }, + { + "step": 951, + "lr": 0.0001, + "sup_loss": 2.2005776007553526 + }, + { + "step": 952, + "lr": 0.0001, + "sup_loss": 2.2005943273716637 + }, + { + "step": 953, + "lr": 0.0001, + "sup_loss": 2.2006424525360546 + }, + { + "step": 954, + "lr": 0.0001, + "sup_loss": 2.2006490719835643 + }, + { + "step": 955, + "lr": 0.0001, + "sup_loss": 2.200704042512074 + }, + { + "step": 956, + "lr": 0.0001, + "sup_loss": 2.2006694548620964 + }, + { + "step": 957, + "lr": 0.0001, + "sup_loss": 2.200626525094939 + }, + { + "step": 958, + "lr": 0.0001, + "sup_loss": 2.200606112550939 + }, + { + "step": 959, + "lr": 0.0001, + "sup_loss": 2.2005982544370966 + }, + { + "step": 960, + "lr": 0.0001, + "sup_loss": 2.2005900404896015 + }, + { + "step": 961, + "lr": 0.0001, + "sup_loss": 2.200604536040705 + }, + { + "step": 962, + "lr": 0.0001, + "sup_loss": 2.200563545980337 + }, + { + "step": 963, + "lr": 0.0001, + "sup_loss": 2.2005799122918095 + }, + { + "step": 964, + "lr": 0.0001, + "sup_loss": 2.200603012205675 + }, + { + "step": 965, + "lr": 0.0001, + "sup_loss": 2.2006176030947344 + }, + { + "step": 966, + "lr": 0.0001, + "sup_loss": 2.2005400615740798 + }, + { + "step": 967, + "lr": 0.0001, + "sup_loss": 2.2005143195860093 + }, + { + "step": 968, + "lr": 0.0001, + "sup_loss": 2.2005005065226158 + }, + { + "step": 969, + "lr": 0.0001, + "sup_loss": 2.2004990272276785 + }, + { + "step": 970, + "lr": 0.0001, + "sup_loss": 2.200492580257006 + }, + { + "step": 971, + "lr": 0.0001, + "sup_loss": 2.200458725549873 + }, + { + "step": 972, + "lr": 0.0001, + "sup_loss": 2.2004423828555275 + }, + { + "step": 973, + "lr": 0.0001, + "sup_loss": 2.2004258274220048 + }, + { + "step": 974, + "lr": 0.0001, + "sup_loss": 2.2004269207549383 + }, + { + "step": 975, + "lr": 0.0001, + "sup_loss": 2.200414739736501 + }, + { + "step": 976, + "lr": 0.0001, + "sup_loss": 2.2004262014769647 + }, + { + "step": 977, + "lr": 0.0001, + "sup_loss": 2.2003791795256644 + }, + { + "step": 978, + "lr": 0.0001, + "sup_loss": 2.200396037914723 + }, + { + "step": 979, + "lr": 0.0001, + "sup_loss": 2.200477982793462 + }, + { + "step": 980, + "lr": 0.0001, + "sup_loss": 2.200341340356937 + }, + { + "step": 981, + "lr": 0.0001, + "sup_loss": 2.200401354211047 + }, + { + "step": 982, + "lr": 0.0001, + "sup_loss": 2.2003606900638646 + }, + { + "step": 983, + "lr": 0.0001, + "sup_loss": 2.200326207252538 + }, + { + "step": 984, + "lr": 0.0001, + "sup_loss": 2.200306684023233 + }, + { + "step": 985, + "lr": 0.0001, + "sup_loss": 2.2003779022976384 + }, + { + "step": 986, + "lr": 0.0001, + "sup_loss": 2.2002869469253072 + }, + { + "step": 987, + "lr": 0.0001, + "sup_loss": 2.20031564672767 + }, + { + "step": 988, + "lr": 0.0001, + "sup_loss": 2.20028136853216 + }, + { + "step": 989, + "lr": 0.0001, + "sup_loss": 2.200307538830476 + }, + { + "step": 990, + "lr": 0.0001, + "sup_loss": 2.2002885020194496 + }, + { + "step": 991, + "lr": 0.0001, + "sup_loss": 2.2002889557195826 + }, + { + "step": 992, + "lr": 0.0001, + "sup_loss": 2.2002816877725673 + }, + { + "step": 993, + "lr": 0.0001, + "sup_loss": 2.2002779711914524 + }, + { + "step": 994, + "lr": 0.0001, + "sup_loss": 2.20027749412057 + }, + { + "step": 995, + "lr": 0.0001, + "sup_loss": 2.200204460959459 + }, + { + "step": 996, + "lr": 0.0001, + "sup_loss": 2.200245971562934 + }, + { + "step": 997, + "lr": 0.0001, + "sup_loss": 2.2002246225638147 + }, + { + "step": 998, + "lr": 0.0001, + "sup_loss": 2.200154875783354 + }, + { + "step": 999, + "lr": 0.0001, + "sup_loss": 2.200170774179006 + }, + { + "step": 1000, + "lr": 0.0001, + "sup_loss": 2.200152132623038 + }, + { + "step": 1001, + "lr": 0.0001, + "sup_loss": 2.200123126639622 + }, + { + "step": 1002, + "lr": 0.0001, + "sup_loss": 2.2000820727908152 + }, + { + "step": 1003, + "lr": 0.0001, + "sup_loss": 2.2001294177845883 + }, + { + "step": 1004, + "lr": 0.0001, + "sup_loss": 2.200089719697746 + }, + { + "step": 1005, + "lr": 0.0001, + "sup_loss": 2.2000960477893075 + }, + { + "step": 1006, + "lr": 0.0001, + "sup_loss": 2.200039012040703 + }, + { + "step": 1007, + "lr": 0.0001, + "sup_loss": 2.200047580688411 + }, + { + "step": 1008, + "lr": 0.0001, + "sup_loss": 2.20007300040131 + }, + { + "step": 1009, + "lr": 0.0001, + "sup_loss": 2.2000459760850934 + }, + { + "step": 1010, + "lr": 0.0001, + "sup_loss": 2.2000368884387402 + }, + { + "step": 1011, + "lr": 0.0001, + "sup_loss": 2.2000319737633323 + }, + { + "step": 1012, + "lr": 0.0001, + "sup_loss": 2.2000096941929947 + }, + { + "step": 1013, + "lr": 0.0001, + "sup_loss": 2.200001100175232 + }, + { + "step": 1014, + "lr": 0.0001, + "sup_loss": 2.199982522419338 + }, + { + "step": 1015, + "lr": 0.0001, + "sup_loss": 2.1999761013368397 + }, + { + "step": 1016, + "lr": 0.0001, + "sup_loss": 2.1999337911813583 + }, + { + "step": 1017, + "lr": 0.0001, + "sup_loss": 2.19992258719513 + }, + { + "step": 1018, + "lr": 0.0001, + "sup_loss": 2.199944568239822 + }, + { + "step": 1019, + "lr": 0.0001, + "sup_loss": 2.1999363223991915 + }, + { + "step": 1020, + "lr": 0.0001, + "sup_loss": 2.199966875624257 + }, + { + "step": 1021, + "lr": 0.0001, + "sup_loss": 2.1999167514441478 + }, + { + "step": 1022, + "lr": 0.0001, + "sup_loss": 2.199928437273929 + }, + { + "step": 1023, + "lr": 0.0001, + "sup_loss": 2.199972623837777 + }, + { + "step": 1024, + "lr": 0.0001, + "sup_loss": 2.1999086882927332 + }, + { + "step": 1025, + "lr": 0.0001, + "sup_loss": 2.199885495047854 + }, + { + "step": 1026, + "lr": 0.0001, + "sup_loss": 2.1998810581449137 + }, + { + "step": 1027, + "lr": 0.0001, + "sup_loss": 2.199839598055426 + }, + { + "step": 1028, + "lr": 0.0001, + "sup_loss": 2.1998644700997385 + }, + { + "step": 1029, + "lr": 0.0001, + "sup_loss": 2.1998387463692413 + }, + { + "step": 1030, + "lr": 0.0001, + "sup_loss": 2.1998004603986794 + }, + { + "step": 1031, + "lr": 0.0001, + "sup_loss": 2.1997942499255787 + }, + { + "step": 1032, + "lr": 0.0001, + "sup_loss": 2.1997862284417704 + }, + { + "step": 1033, + "lr": 0.0001, + "sup_loss": 2.199747647718616 + }, + { + "step": 1034, + "lr": 0.0001, + "sup_loss": 2.199735649805482 + }, + { + "step": 1035, + "lr": 0.0001, + "sup_loss": 2.199749866905596 + }, + { + "step": 1036, + "lr": 0.0001, + "sup_loss": 2.1997345347953323 + }, + { + "step": 1037, + "lr": 0.0001, + "sup_loss": 2.1997237819492903 + }, + { + "step": 1038, + "lr": 0.0001, + "sup_loss": 2.1996922483285575 + }, + { + "step": 1039, + "lr": 0.0001, + "sup_loss": 2.1997045150312546 + }, + { + "step": 1040, + "lr": 0.0001, + "sup_loss": 2.1997188897628455 + }, + { + "step": 1041, + "lr": 0.0001, + "sup_loss": 2.199685198413937 + }, + { + "step": 1042, + "lr": 0.0001, + "sup_loss": 2.1996954837943803 + }, + { + "step": 1043, + "lr": 0.0001, + "sup_loss": 2.199670071361164 + }, + { + "step": 1044, + "lr": 0.0001, + "sup_loss": 2.199645848764149 + }, + { + "step": 1045, + "lr": 0.0001, + "sup_loss": 2.19964314777715 + }, + { + "step": 1046, + "lr": 0.0001, + "sup_loss": 2.199642974218232 + }, + { + "step": 1047, + "lr": 0.0001, + "sup_loss": 2.199618373713803 + }, + { + "step": 1048, + "lr": 0.0001, + "sup_loss": 2.1996509077524715 + }, + { + "step": 1049, + "lr": 0.0001, + "sup_loss": 2.1996557869564555 + }, + { + "step": 1050, + "lr": 0.0001, + "sup_loss": 2.19967401554275 + }, + { + "step": 1051, + "lr": 0.0001, + "sup_loss": 2.1996037373874597 + }, + { + "step": 1052, + "lr": 0.0001, + "sup_loss": 2.199609065508618 + }, + { + "step": 1053, + "lr": 0.0001, + "sup_loss": 2.199570985980483 + }, + { + "step": 1054, + "lr": 0.0001, + "sup_loss": 2.199592704380824 + }, + { + "step": 1055, + "lr": 0.0001, + "sup_loss": 2.199584954867057 + }, + { + "step": 1056, + "lr": 0.0001, + "sup_loss": 2.1995616568797214 + }, + { + "step": 1057, + "lr": 0.0001, + "sup_loss": 2.1995645198866614 + }, + { + "step": 1058, + "lr": 0.0001, + "sup_loss": 2.199551927143007 + }, + { + "step": 1059, + "lr": 0.0001, + "sup_loss": 2.1995462030655917 + }, + { + "step": 1060, + "lr": 0.0001, + "sup_loss": 2.19956604561359 + }, + { + "step": 1061, + "lr": 0.0001, + "sup_loss": 2.199545915221313 + }, + { + "step": 1062, + "lr": 0.0001, + "sup_loss": 2.1995392367732625 + }, + { + "step": 1063, + "lr": 0.0001, + "sup_loss": 2.199521038880376 + }, + { + "step": 1064, + "lr": 0.0001, + "sup_loss": 2.1995269139986333 + }, + { + "step": 1065, + "lr": 0.0001, + "sup_loss": 2.1995200485373623 + }, + { + "step": 1066, + "lr": 0.0001, + "sup_loss": 2.1995186151247195 + }, + { + "step": 1067, + "lr": 0.0001, + "sup_loss": 2.199518492577736 + }, + { + "step": 1068, + "lr": 0.0001, + "sup_loss": 2.199494496684978 + }, + { + "step": 1069, + "lr": 0.0001, + "sup_loss": 2.1995362990303224 + }, + { + "step": 1070, + "lr": 0.0001, + "sup_loss": 2.1994951113430603 + }, + { + "step": 1071, + "lr": 0.0001, + "sup_loss": 2.1994625488393638 + }, + { + "step": 1072, + "lr": 0.0001, + "sup_loss": 2.1994905797579283 + }, + { + "step": 1073, + "lr": 0.0001, + "sup_loss": 2.199450651182908 + }, + { + "step": 1074, + "lr": 0.0001, + "sup_loss": 2.199503807909498 + }, + { + "step": 1075, + "lr": 0.0001, + "sup_loss": 2.1994931536690334 + }, + { + "step": 1076, + "lr": 0.0001, + "sup_loss": 2.199529656481996 + }, + { + "step": 1077, + "lr": 0.0001, + "sup_loss": 2.199567277573229 + }, + { + "step": 1078, + "lr": 0.0001, + "sup_loss": 2.199570137949851 + }, + { + "step": 1079, + "lr": 0.0001, + "sup_loss": 2.1995576338693583 + }, + { + "step": 1080, + "lr": 0.0001, + "sup_loss": 2.1995400524140685 + }, + { + "step": 1081, + "lr": 0.0001, + "sup_loss": 2.199544749921104 + }, + { + "step": 1082, + "lr": 0.0001, + "sup_loss": 2.199523424111251 + }, + { + "step": 1083, + "lr": 0.0001, + "sup_loss": 2.199530935857992 + }, + { + "step": 1084, + "lr": 0.0001, + "sup_loss": 2.199531235751161 + }, + { + "step": 1085, + "lr": 0.0001, + "sup_loss": 2.199517012778417 + }, + { + "step": 1086, + "lr": 0.0001, + "sup_loss": 2.1995045528835346 + }, + { + "step": 1087, + "lr": 0.0001, + "sup_loss": 2.1994495465430415 + }, + { + "step": 1088, + "lr": 0.0001, + "sup_loss": 2.1994685442866464 + }, + { + "step": 1089, + "lr": 0.0001, + "sup_loss": 2.199474817517819 + }, + { + "step": 1090, + "lr": 0.0001, + "sup_loss": 2.1994825501722386 + }, + { + "step": 1091, + "lr": 0.0001, + "sup_loss": 2.19944660607929 + }, + { + "step": 1092, + "lr": 0.0001, + "sup_loss": 2.1994372522945436 + }, + { + "step": 1093, + "lr": 0.0001, + "sup_loss": 2.1994283388084943 + }, + { + "step": 1094, + "lr": 0.0001, + "sup_loss": 2.199417457881726 + }, + { + "step": 1095, + "lr": 0.0001, + "sup_loss": 2.1993210717523723 + }, + { + "step": 1096, + "lr": 0.0001, + "sup_loss": 2.199332428904555 + }, + { + "step": 1097, + "lr": 0.0001, + "sup_loss": 2.1993186690438313 + }, + { + "step": 1098, + "lr": 0.0001, + "sup_loss": 2.1992878663643074 + }, + { + "step": 1099, + "lr": 0.0001, + "sup_loss": 2.199269755726869 + }, + { + "step": 1100, + "lr": 0.0001, + "sup_loss": 2.19925145552739 + }, + { + "step": 1101, + "lr": 0.0001, + "sup_loss": 2.1992518666132597 + }, + { + "step": 1102, + "lr": 0.0001, + "sup_loss": 2.1992957314894963 + }, + { + "step": 1103, + "lr": 0.0001, + "sup_loss": 2.1992783264386637 + }, + { + "step": 1104, + "lr": 0.0001, + "sup_loss": 2.1992670326953783 + }, + { + "step": 1105, + "lr": 0.0001, + "sup_loss": 2.1992384990166727 + }, + { + "step": 1106, + "lr": 0.0001, + "sup_loss": 2.199196805183956 + }, + { + "step": 1107, + "lr": 0.0001, + "sup_loss": 2.1991809934782047 + }, + { + "step": 1108, + "lr": 0.0001, + "sup_loss": 2.199143378314656 + }, + { + "step": 1109, + "lr": 0.0001, + "sup_loss": 2.199163337325676 + }, + { + "step": 1110, + "lr": 0.0001, + "sup_loss": 2.199126389031877 + }, + { + "step": 1111, + "lr": 0.0001, + "sup_loss": 2.1991844594380856 + }, + { + "step": 1112, + "lr": 0.0001, + "sup_loss": 2.1991754961201706 + }, + { + "step": 1113, + "lr": 0.0001, + "sup_loss": 2.1990774818311274 + }, + { + "step": 1114, + "lr": 0.0001, + "sup_loss": 2.1991209434801418 + }, + { + "step": 1115, + "lr": 0.0001, + "sup_loss": 2.199066154064319 + }, + { + "step": 1116, + "lr": 0.0001, + "sup_loss": 2.199076691530373 + }, + { + "step": 1117, + "lr": 0.0001, + "sup_loss": 2.199041507412553 + }, + { + "step": 1118, + "lr": 0.0001, + "sup_loss": 2.1990874171693586 + }, + { + "step": 1119, + "lr": 0.0001, + "sup_loss": 2.1990609679735384 + }, + { + "step": 1120, + "lr": 0.0001, + "sup_loss": 2.199153621915959 + }, + { + "step": 1121, + "lr": 0.0001, + "sup_loss": 2.1990249358796774 + }, + { + "step": 1122, + "lr": 0.0001, + "sup_loss": 2.1991705049235373 + }, + { + "step": 1123, + "lr": 0.0001, + "sup_loss": 2.1991556074655274 + }, + { + "step": 1124, + "lr": 0.0001, + "sup_loss": 2.199048519912572 + }, + { + "step": 1125, + "lr": 0.0001, + "sup_loss": 2.199147223652934 + }, + { + "step": 1126, + "lr": 0.0001, + "sup_loss": 2.1991837508500582 + }, + { + "step": 1127, + "lr": 0.0001, + "sup_loss": 2.199057980727179 + }, + { + "step": 1128, + "lr": 0.0001, + "sup_loss": 2.199039405959408 + }, + { + "step": 1129, + "lr": 0.0001, + "sup_loss": 2.1991170615568763 + }, + { + "step": 1130, + "lr": 0.0001, + "sup_loss": 2.1991429155294786 + }, + { + "step": 1131, + "lr": 0.0001, + "sup_loss": 2.199125921911959 + }, + { + "step": 1132, + "lr": 0.0001, + "sup_loss": 2.199197670724437 + }, + { + "step": 1133, + "lr": 0.0001, + "sup_loss": 2.1992333905048493 + }, + { + "step": 1134, + "lr": 0.0001, + "sup_loss": 2.199188478382472 + }, + { + "step": 1135, + "lr": 0.0001, + "sup_loss": 2.1993502743496913 + }, + { + "step": 1136, + "lr": 0.0001, + "sup_loss": 2.1989827273637825 + }, + { + "step": 1137, + "lr": 0.0001, + "sup_loss": 2.1991922303869846 + }, + { + "step": 1138, + "lr": 0.0001, + "sup_loss": 2.199330779996429 + }, + { + "step": 1139, + "lr": 0.0001, + "sup_loss": 2.1989318491569216 + }, + { + "step": 1140, + "lr": 0.0001, + "sup_loss": 2.198969194766669 + }, + { + "step": 1141, + "lr": 0.0001, + "sup_loss": 2.199282688806128 + }, + { + "step": 1142, + "lr": 0.0001, + "sup_loss": 2.1990426352614945 + }, + { + "step": 1143, + "lr": 0.0001, + "sup_loss": 2.19936078664714 + }, + { + "step": 1144, + "lr": 0.0001, + "sup_loss": 2.199149592884414 + }, + { + "step": 1145, + "lr": 0.0001, + "sup_loss": 2.1992281758126677 + }, + { + "step": 1146, + "lr": 0.0001, + "sup_loss": 2.1993484428419423 + }, + { + "step": 1147, + "lr": 0.0001, + "sup_loss": 2.199302259111751 + }, + { + "step": 1148, + "lr": 0.0001, + "sup_loss": 2.199247150021272 + }, + { + "step": 1149, + "lr": 0.0001, + "sup_loss": 2.199146114391339 + }, + { + "step": 1150, + "lr": 0.0001, + "sup_loss": 2.1991673406190175 + }, + { + "step": 1151, + "lr": 0.0001, + "sup_loss": 2.199213709666499 + }, + { + "step": 1152, + "lr": 0.0001, + "sup_loss": 2.199069468059086 + }, + { + "step": 1153, + "lr": 0.0001, + "sup_loss": 2.1993353191763236 + }, + { + "step": 1154, + "lr": 0.0001, + "sup_loss": 2.19910503459144 + }, + { + "step": 1155, + "lr": 0.0001, + "sup_loss": 2.199116997874 + }, + { + "step": 1156, + "lr": 0.0001, + "sup_loss": 2.1991570673834806 + }, + { + "step": 1157, + "lr": 0.0001, + "sup_loss": 2.1991136904167323 + }, + { + "step": 1158, + "lr": 0.0001, + "sup_loss": 2.199033044238992 + }, + { + "step": 1159, + "lr": 0.0001, + "sup_loss": 2.1991510169130297 + }, + { + "step": 1160, + "lr": 0.0001, + "sup_loss": 2.1991465413412503 + }, + { + "step": 1161, + "lr": 0.0001, + "sup_loss": 2.1991487789996085 + }, + { + "step": 1162, + "lr": 0.0001, + "sup_loss": 2.19916218537416 + }, + { + "step": 1163, + "lr": 0.0001, + "sup_loss": 2.1990684613144285 + }, + { + "step": 1164, + "lr": 0.0001, + "sup_loss": 2.199097756205079 + }, + { + "step": 1165, + "lr": 0.0001, + "sup_loss": 2.19906126134195 + }, + { + "step": 1166, + "lr": 0.0001, + "sup_loss": 2.1992141112430277 + }, + { + "step": 1167, + "lr": 0.0001, + "sup_loss": 2.1991537735508677 + }, + { + "step": 1168, + "lr": 0.0001, + "sup_loss": 2.198956108039192 + }, + { + "step": 1169, + "lr": 0.0001, + "sup_loss": 2.1990707656097963 + }, + { + "step": 1170, + "lr": 0.0001, + "sup_loss": 2.1990771153739637 + }, + { + "step": 1171, + "lr": 0.0001, + "sup_loss": 2.199127978329333 + }, + { + "step": 1172, + "lr": 0.0001, + "sup_loss": 2.199211950838545 + }, + { + "step": 1173, + "lr": 0.0001, + "sup_loss": 2.1991126997806005 + }, + { + "step": 1174, + "lr": 0.0001, + "sup_loss": 2.199055547521239 + }, + { + "step": 1175, + "lr": 0.0001, + "sup_loss": 2.198971954405323 + }, + { + "step": 1176, + "lr": 0.0001, + "sup_loss": 2.1990269338485975 + }, + { + "step": 1177, + "lr": 0.0001, + "sup_loss": 2.1989733387250125 + }, + { + "step": 1178, + "lr": 0.0001, + "sup_loss": 2.1990127711876353 + }, + { + "step": 1179, + "lr": 0.0001, + "sup_loss": 2.199019559918397 + }, + { + "step": 1180, + "lr": 0.0001, + "sup_loss": 2.1991616277263386 + }, + { + "step": 1181, + "lr": 0.0001, + "sup_loss": 2.1991851949446657 + }, + { + "step": 1182, + "lr": 0.0001, + "sup_loss": 2.1990610725823005 + }, + { + "step": 1183, + "lr": 0.0001, + "sup_loss": 2.1990132186441746 + }, + { + "step": 1184, + "lr": 0.0001, + "sup_loss": 2.1990634856175277 + }, + { + "step": 1185, + "lr": 0.0001, + "sup_loss": 2.1990050594312325 + }, + { + "step": 1186, + "lr": 0.0001, + "sup_loss": 2.1990561128604718 + }, + { + "step": 1187, + "lr": 0.0001, + "sup_loss": 2.199103046483348 + }, + { + "step": 1188, + "lr": 0.0001, + "sup_loss": 2.199015402380846 + }, + { + "step": 1189, + "lr": 0.0001, + "sup_loss": 2.1989962030453722 + }, + { + "step": 1190, + "lr": 0.0001, + "sup_loss": 2.198960930811251 + }, + { + "step": 1191, + "lr": 0.0001, + "sup_loss": 2.198934533754799 + }, + { + "step": 1192, + "lr": 0.0001, + "sup_loss": 2.1989639868601447 + }, + { + "step": 1193, + "lr": 0.0001, + "sup_loss": 2.199044778588006 + }, + { + "step": 1194, + "lr": 0.0001, + "sup_loss": 2.1989369921809025 + }, + { + "step": 1195, + "lr": 0.0001, + "sup_loss": 2.1989268960761885 + }, + { + "step": 1196, + "lr": 0.0001, + "sup_loss": 2.199027112705364 + }, + { + "step": 1197, + "lr": 0.0001, + "sup_loss": 2.198959669558059 + }, + { + "step": 1198, + "lr": 0.0001, + "sup_loss": 2.199031743917905 + }, + { + "step": 1199, + "lr": 0.0001, + "sup_loss": 2.198960115454357 + }, + { + "step": 1200, + "lr": 0.0001, + "sup_loss": 2.199029076694603 + }, + { + "step": 1201, + "lr": 0.0001, + "sup_loss": 2.1990111112199604 + }, + { + "step": 1202, + "lr": 0.0001, + "sup_loss": 2.1990717414772343 + }, + { + "step": 1203, + "lr": 0.0001, + "sup_loss": 2.199066035530352 + }, + { + "step": 1204, + "lr": 0.0001, + "sup_loss": 2.198993790661039 + }, + { + "step": 1205, + "lr": 0.0001, + "sup_loss": 2.199010079249905 + }, + { + "step": 1206, + "lr": 0.0001, + "sup_loss": 2.199043932286836 + }, + { + "step": 1207, + "lr": 0.0001, + "sup_loss": 2.1990003263787488 + }, + { + "step": 1208, + "lr": 0.0001, + "sup_loss": 2.198967707679285 + }, + { + "step": 1209, + "lr": 0.0001, + "sup_loss": 2.1990587136417403 + }, + { + "step": 1210, + "lr": 0.0001, + "sup_loss": 2.199006218629253 + }, + { + "step": 1211, + "lr": 0.0001, + "sup_loss": 2.1989909487161983 + }, + { + "step": 1212, + "lr": 0.0001, + "sup_loss": 2.198920587210497 + }, + { + "step": 1213, + "lr": 0.0001, + "sup_loss": 2.1990435052866957 + }, + { + "step": 1214, + "lr": 0.0001, + "sup_loss": 2.1989870279771115 + }, + { + "step": 1215, + "lr": 0.0001, + "sup_loss": 2.1990140116344303 + }, + { + "step": 1216, + "lr": 0.0001, + "sup_loss": 2.1989684414104493 + }, + { + "step": 1217, + "lr": 0.0001, + "sup_loss": 2.198922144540893 + }, + { + "step": 1218, + "lr": 0.0001, + "sup_loss": 2.1989014805041194 + }, + { + "step": 1219, + "lr": 0.0001, + "sup_loss": 2.1989225590662302 + }, + { + "step": 1220, + "lr": 0.0001, + "sup_loss": 2.198898919500716 + }, + { + "step": 1221, + "lr": 0.0001, + "sup_loss": 2.198988271963199 + }, + { + "step": 1222, + "lr": 0.0001, + "sup_loss": 2.199027697429467 + }, + { + "step": 1223, + "lr": 0.0001, + "sup_loss": 2.1988772921505673 + }, + { + "step": 1224, + "lr": 0.0001, + "sup_loss": 2.1988855231293076 + }, + { + "step": 1225, + "lr": 0.0001, + "sup_loss": 2.198861025399836 + }, + { + "step": 1226, + "lr": 0.0001, + "sup_loss": 2.1987835814172714 + }, + { + "step": 1227, + "lr": 0.0001, + "sup_loss": 2.198839860581799 + }, + { + "step": 1228, + "lr": 0.0001, + "sup_loss": 2.1988062101197117 + }, + { + "step": 1229, + "lr": 0.0001, + "sup_loss": 2.1988057111512713 + }, + { + "step": 1230, + "lr": 0.0001, + "sup_loss": 2.198890993846529 + }, + { + "step": 1231, + "lr": 0.0001, + "sup_loss": 2.1988007970325354 + }, + { + "step": 1232, + "lr": 0.0001, + "sup_loss": 2.198791882629915 + }, + { + "step": 1233, + "lr": 0.0001, + "sup_loss": 2.198770487994753 + }, + { + "step": 1234, + "lr": 0.0001, + "sup_loss": 2.198733079298889 + }, + { + "step": 1235, + "lr": 0.0001, + "sup_loss": 2.1986140066373827 + }, + { + "step": 1236, + "lr": 0.0001, + "sup_loss": 2.1986666050541297 + }, + { + "step": 1237, + "lr": 0.0001, + "sup_loss": 2.1987679074329827 + }, + { + "step": 1238, + "lr": 0.0001, + "sup_loss": 2.1986529710912377 + }, + { + "step": 1239, + "lr": 0.0001, + "sup_loss": 2.1986101228710107 + }, + { + "step": 1240, + "lr": 0.0001, + "sup_loss": 2.1987555700101096 + }, + { + "step": 1241, + "lr": 0.0001, + "sup_loss": 2.1987869896333665 + }, + { + "step": 1242, + "lr": 0.0001, + "sup_loss": 2.1987757524025238 + }, + { + "step": 1243, + "lr": 0.0001, + "sup_loss": 2.1987713329658285 + }, + { + "step": 1244, + "lr": 0.0001, + "sup_loss": 2.1986159966611813 + }, + { + "step": 1245, + "lr": 0.0001, + "sup_loss": 2.1985927130087815 + }, + { + "step": 1246, + "lr": 0.0001, + "sup_loss": 2.1985890664723478 + }, + { + "step": 1247, + "lr": 0.0001, + "sup_loss": 2.198657764876899 + }, + { + "step": 1248, + "lr": 0.0001, + "sup_loss": 2.198681942345739 + }, + { + "step": 1249, + "lr": 0.0001, + "sup_loss": 2.1986909137898785 + }, + { + "step": 1250, + "lr": 0.0001, + "sup_loss": 2.198650545323616 + }, + { + "step": 1251, + "lr": 0.0001, + "sup_loss": 2.198689064839419 + }, + { + "step": 1252, + "lr": 0.0001, + "sup_loss": 2.1986445359325533 + }, + { + "step": 1253, + "lr": 0.0001, + "sup_loss": 2.198613675577668 + }, + { + "step": 1254, + "lr": 0.0001, + "sup_loss": 2.198563426124381 + }, + { + "step": 1255, + "lr": 0.0001, + "sup_loss": 2.1986283624486833 + }, + { + "step": 1256, + "lr": 0.0001, + "sup_loss": 2.1987369926574716 + }, + { + "step": 1257, + "lr": 0.0001, + "sup_loss": 2.198687812301948 + }, + { + "step": 1258, + "lr": 0.0001, + "sup_loss": 2.198747534839166 + }, + { + "step": 1259, + "lr": 0.0001, + "sup_loss": 2.1987128546417822 + }, + { + "step": 1260, + "lr": 0.0001, + "sup_loss": 2.198665624899237 + }, + { + "step": 1261, + "lr": 0.0001, + "sup_loss": 2.198575327423013 + }, + { + "step": 1262, + "lr": 0.0001, + "sup_loss": 2.198603522940399 + }, + { + "step": 1263, + "lr": 0.0001, + "sup_loss": 2.1986348774234 + }, + { + "step": 1264, + "lr": 0.0001, + "sup_loss": 2.1986020057540983 + }, + { + "step": 1265, + "lr": 0.0001, + "sup_loss": 2.198754673391454 + }, + { + "step": 1266, + "lr": 0.0001, + "sup_loss": 2.198650352835629 + }, + { + "step": 1267, + "lr": 0.0001, + "sup_loss": 2.1987392592332755 + }, + { + "step": 1268, + "lr": 0.0001, + "sup_loss": 2.1987664746852564 + }, + { + "step": 1269, + "lr": 0.0001, + "sup_loss": 2.198518517904745 + }, + { + "step": 1270, + "lr": 0.0001, + "sup_loss": 2.198576817127274 + }, + { + "step": 1271, + "lr": 0.0001, + "sup_loss": 2.198621407368558 + }, + { + "step": 1272, + "lr": 0.0001, + "sup_loss": 2.198533816326139 + }, + { + "step": 1273, + "lr": 0.0001, + "sup_loss": 2.198610185110971 + }, + { + "step": 1274, + "lr": 0.0001, + "sup_loss": 2.1987518602535028 + }, + { + "step": 1275, + "lr": 0.0001, + "sup_loss": 2.198655017640015 + }, + { + "step": 1276, + "lr": 0.0001, + "sup_loss": 2.198603802668048 + }, + { + "step": 1277, + "lr": 0.0001, + "sup_loss": 2.198538105160702 + }, + { + "step": 1278, + "lr": 0.0001, + "sup_loss": 2.1986216048844813 + }, + { + "step": 1279, + "lr": 0.0001, + "sup_loss": 2.198677261705949 + }, + { + "step": 1280, + "lr": 0.0001, + "sup_loss": 2.1986110694744925 + }, + { + "step": 1281, + "lr": 0.0001, + "sup_loss": 2.198489895867369 + }, + { + "step": 1282, + "lr": 0.0001, + "sup_loss": 2.198590949515596 + }, + { + "step": 1283, + "lr": 0.0001, + "sup_loss": 2.1985318614273264 + }, + { + "step": 1284, + "lr": 0.0001, + "sup_loss": 2.19858910618376 + }, + { + "step": 1285, + "lr": 0.0001, + "sup_loss": 2.1985461008336706 + }, + { + "step": 1286, + "lr": 0.0001, + "sup_loss": 2.1985360375444167 + }, + { + "step": 1287, + "lr": 0.0001, + "sup_loss": 2.19868777772313 + }, + { + "step": 1288, + "lr": 0.0001, + "sup_loss": 2.1985719197199556 + }, + { + "step": 1289, + "lr": 0.0001, + "sup_loss": 2.198465445148978 + }, + { + "step": 1290, + "lr": 0.0001, + "sup_loss": 2.1985869788781196 + }, + { + "step": 1291, + "lr": 0.0001, + "sup_loss": 2.1985226539091114 + }, + { + "step": 1292, + "lr": 0.0001, + "sup_loss": 2.198494762387587 + }, + { + "step": 1293, + "lr": 0.0001, + "sup_loss": 2.198489240567357 + }, + { + "step": 1294, + "lr": 0.0001, + "sup_loss": 2.1985296630999898 + }, + { + "step": 1295, + "lr": 0.0001, + "sup_loss": 2.198555105335445 + }, + { + "step": 1296, + "lr": 0.0001, + "sup_loss": 2.198491533780298 + }, + { + "step": 1297, + "lr": 0.0001, + "sup_loss": 2.1986295568957845 + }, + { + "step": 1298, + "lr": 0.0001, + "sup_loss": 2.198461693544685 + }, + { + "step": 1299, + "lr": 0.0001, + "sup_loss": 2.1985276378137084 + }, + { + "step": 1300, + "lr": 0.0001, + "sup_loss": 2.1985167496551163 + }, + { + "step": 1301, + "lr": 0.0001, + "sup_loss": 2.198677273570196 + }, + { + "step": 1302, + "lr": 0.0001, + "sup_loss": 2.1985152068049603 + }, + { + "step": 1303, + "lr": 0.0001, + "sup_loss": 2.1985874323220655 + }, + { + "step": 1304, + "lr": 0.0001, + "sup_loss": 2.1984270302372164 + }, + { + "step": 1305, + "lr": 0.0001, + "sup_loss": 2.1985684538270642 + }, + { + "step": 1306, + "lr": 0.0001, + "sup_loss": 2.198608213562534 + }, + { + "step": 1307, + "lr": 0.0001, + "sup_loss": 2.1986049310375884 + }, + { + "step": 1308, + "lr": 0.0001, + "sup_loss": 2.198643713664338 + }, + { + "step": 1309, + "lr": 0.0001, + "sup_loss": 2.1985397342168564 + }, + { + "step": 1310, + "lr": 0.0001, + "sup_loss": 2.198680732986179 + }, + { + "step": 1311, + "lr": 0.0001, + "sup_loss": 2.1986062031598896 + }, + { + "step": 1312, + "lr": 0.0001, + "sup_loss": 2.1986157307011966 + }, + { + "step": 1313, + "lr": 0.0001, + "sup_loss": 2.198631504956035 + }, + { + "step": 1314, + "lr": 0.0001, + "sup_loss": 2.198487458699185 + }, + { + "step": 1315, + "lr": 0.0001, + "sup_loss": 2.198496302845588 + }, + { + "step": 1316, + "lr": 0.0001, + "sup_loss": 2.1984736267596845 + }, + { + "step": 1317, + "lr": 0.0001, + "sup_loss": 2.1986182814969277 + }, + { + "step": 1318, + "lr": 0.0001, + "sup_loss": 2.198520052910187 + }, + { + "step": 1319, + "lr": 0.0001, + "sup_loss": 2.1985467269274195 + }, + { + "step": 1320, + "lr": 0.0001, + "sup_loss": 2.1985768261182104 + }, + { + "step": 1321, + "lr": 0.0001, + "sup_loss": 2.198704262155016 + }, + { + "step": 1322, + "lr": 0.0001, + "sup_loss": 2.19851547803927 + }, + { + "step": 1323, + "lr": 0.0001, + "sup_loss": 2.1985326141127883 + }, + { + "step": 1324, + "lr": 0.0001, + "sup_loss": 2.198560018917768 + }, + { + "step": 1325, + "lr": 0.0001, + "sup_loss": 2.1985996855499623 + }, + { + "step": 1326, + "lr": 0.0001, + "sup_loss": 2.1986357431620727 + }, + { + "step": 1327, + "lr": 0.0001, + "sup_loss": 2.1986029479467515 + }, + { + "step": 1328, + "lr": 0.0001, + "sup_loss": 2.1986948339567145 + }, + { + "step": 1329, + "lr": 0.0001, + "sup_loss": 2.198576087744065 + }, + { + "step": 1330, + "lr": 0.0001, + "sup_loss": 2.198585404051163 + }, + { + "step": 1331, + "lr": 0.0001, + "sup_loss": 2.1985735964618023 + }, + { + "step": 1332, + "lr": 0.0001, + "sup_loss": 2.1985810238122623 + }, + { + "step": 1333, + "lr": 0.0001, + "sup_loss": 2.198645303341678 + }, + { + "step": 1334, + "lr": 0.0001, + "sup_loss": 2.198629236420537 + }, + { + "step": 1335, + "lr": 0.0001, + "sup_loss": 2.1986947362447427 + }, + { + "step": 1336, + "lr": 0.0001, + "sup_loss": 2.1984878495699345 + }, + { + "step": 1337, + "lr": 0.0001, + "sup_loss": 2.198557804795796 + }, + { + "step": 1338, + "lr": 0.0001, + "sup_loss": 2.198625568012851 + }, + { + "step": 1339, + "lr": 0.0001, + "sup_loss": 2.198524194907555 + }, + { + "step": 1340, + "lr": 0.0001, + "sup_loss": 2.198545859802001 + }, + { + "step": 1341, + "lr": 0.0001, + "sup_loss": 2.1984971400487336 + }, + { + "step": 1342, + "lr": 0.0001, + "sup_loss": 2.198531275393674 + }, + { + "step": 1343, + "lr": 0.0001, + "sup_loss": 2.1985157669444177 + }, + { + "step": 1344, + "lr": 0.0001, + "sup_loss": 2.198513769434965 + }, + { + "step": 1345, + "lr": 0.0001, + "sup_loss": 2.19851536128539 + }, + { + "step": 1346, + "lr": 0.0001, + "sup_loss": 2.198496417399127 + }, + { + "step": 1347, + "lr": 0.0001, + "sup_loss": 2.198506261032089 + }, + { + "step": 1348, + "lr": 0.0001, + "sup_loss": 2.1985844660686666 + }, + { + "step": 1349, + "lr": 0.0001, + "sup_loss": 2.19861169831354 + }, + { + "step": 1350, + "lr": 0.0001, + "sup_loss": 2.198495246470478 + }, + { + "step": 1351, + "lr": 0.0001, + "sup_loss": 2.1986011740145415 + }, + { + "step": 1352, + "lr": 0.0001, + "sup_loss": 2.198485005706478 + }, + { + "step": 1353, + "lr": 0.0001, + "sup_loss": 2.198631362252362 + }, + { + "step": 1354, + "lr": 0.0001, + "sup_loss": 2.1986098657484474 + }, + { + "step": 1355, + "lr": 0.0001, + "sup_loss": 2.198492148620744 + }, + { + "step": 1356, + "lr": 0.0001, + "sup_loss": 2.1984616705115942 + }, + { + "step": 1357, + "lr": 0.0001, + "sup_loss": 2.1984808108633884 + }, + { + "step": 1358, + "lr": 0.0001, + "sup_loss": 2.198477950810407 + }, + { + "step": 1359, + "lr": 0.0001, + "sup_loss": 2.198413631017042 + }, + { + "step": 1360, + "lr": 0.0001, + "sup_loss": 2.1985387781488734 + }, + { + "step": 1361, + "lr": 0.0001, + "sup_loss": 2.1984930398324996 + }, + { + "step": 1362, + "lr": 0.0001, + "sup_loss": 2.1985500478907234 + }, + { + "step": 1363, + "lr": 0.0001, + "sup_loss": 2.198471089381199 + }, + { + "step": 1364, + "lr": 0.0001, + "sup_loss": 2.1985061909771226 + }, + { + "step": 1365, + "lr": 0.0001, + "sup_loss": 2.198498557753367 + }, + { + "step": 1366, + "lr": 0.0001, + "sup_loss": 2.1984815008788527 + }, + { + "step": 1367, + "lr": 0.0001, + "sup_loss": 2.198469861957429 + }, + { + "step": 1368, + "lr": 0.0001, + "sup_loss": 2.198448843029766 + }, + { + "step": 1369, + "lr": 0.0001, + "sup_loss": 2.1984370084502793 + }, + { + "step": 1370, + "lr": 0.0001, + "sup_loss": 2.198492485511994 + }, + { + "step": 1371, + "lr": 0.0001, + "sup_loss": 2.1984755887025975 + }, + { + "step": 1372, + "lr": 0.0001, + "sup_loss": 2.198435107923012 + }, + { + "step": 1373, + "lr": 0.0001, + "sup_loss": 2.1985426509895856 + }, + { + "step": 1374, + "lr": 0.0001, + "sup_loss": 2.1985433565101644 + }, + { + "step": 1375, + "lr": 0.0001, + "sup_loss": 2.198412253408429 + }, + { + "step": 1376, + "lr": 0.0001, + "sup_loss": 2.198474477188624 + }, + { + "step": 1377, + "lr": 0.0001, + "sup_loss": 2.198411906140026 + }, + { + "step": 1378, + "lr": 0.0001, + "sup_loss": 2.198444501507635 + }, + { + "step": 1379, + "lr": 0.0001, + "sup_loss": 2.198422946522463 + }, + { + "step": 1380, + "lr": 0.0001, + "sup_loss": 2.198460525677628 + }, + { + "step": 1381, + "lr": 0.0001, + "sup_loss": 2.198481735115675 + }, + { + "step": 1382, + "lr": 0.0001, + "sup_loss": 2.1984323540050643 + }, + { + "step": 1383, + "lr": 0.0001, + "sup_loss": 2.1984176244431097 + }, + { + "step": 1384, + "lr": 0.0001, + "sup_loss": 2.198474641879872 + }, + { + "step": 1385, + "lr": 0.0001, + "sup_loss": 2.198461574796765 + }, + { + "step": 1386, + "lr": 0.0001, + "sup_loss": 2.1984044846650015 + }, + { + "step": 1387, + "lr": 0.0001, + "sup_loss": 2.1984102886905452 + }, + { + "step": 1388, + "lr": 0.0001, + "sup_loss": 2.1984210292540998 + }, + { + "step": 1389, + "lr": 0.0001, + "sup_loss": 2.1983160061804927 + }, + { + "step": 1390, + "lr": 0.0001, + "sup_loss": 2.1984201493904236 + }, + { + "step": 1391, + "lr": 0.0001, + "sup_loss": 2.1984304338366325 + }, + { + "step": 1392, + "lr": 0.0001, + "sup_loss": 2.1983512275709756 + }, + { + "step": 1393, + "lr": 0.0001, + "sup_loss": 2.198403382872034 + }, + { + "step": 1394, + "lr": 0.0001, + "sup_loss": 2.1982827791881236 + }, + { + "step": 1395, + "lr": 0.0001, + "sup_loss": 2.1983131029686462 + }, + { + "step": 1396, + "lr": 0.0001, + "sup_loss": 2.1983178322932444 + }, + { + "step": 1397, + "lr": 0.0001, + "sup_loss": 2.1983650884200836 + }, + { + "step": 1398, + "lr": 0.0001, + "sup_loss": 2.198284694046373 + }, + { + "step": 1399, + "lr": 0.0001, + "sup_loss": 2.1983550571693646 + }, + { + "step": 1400, + "lr": 0.0001, + "sup_loss": 2.1983480685874968 + }, + { + "step": 1401, + "lr": 0.0001, + "sup_loss": 2.198376133791097 + }, + { + "step": 1402, + "lr": 0.0001, + "sup_loss": 2.198314657071542 + }, + { + "step": 1403, + "lr": 0.0001, + "sup_loss": 2.1982456306855505 + }, + { + "step": 1404, + "lr": 0.0001, + "sup_loss": 2.1982666042232966 + }, + { + "step": 1405, + "lr": 0.0001, + "sup_loss": 2.1983157878847517 + }, + { + "step": 1406, + "lr": 0.0001, + "sup_loss": 2.198312910691103 + }, + { + "step": 1407, + "lr": 0.0001, + "sup_loss": 2.1982683189918855 + }, + { + "step": 1408, + "lr": 0.0001, + "sup_loss": 2.1983390781266086 + }, + { + "step": 1409, + "lr": 0.0001, + "sup_loss": 2.1982497052760626 + }, + { + "step": 1410, + "lr": 0.0001, + "sup_loss": 2.1982888661042623 + }, + { + "step": 1411, + "lr": 0.0001, + "sup_loss": 2.198283358117664 + }, + { + "step": 1412, + "lr": 0.0001, + "sup_loss": 2.198250362866095 + }, + { + "step": 1413, + "lr": 0.0001, + "sup_loss": 2.1982813338061016 + }, + { + "step": 1414, + "lr": 0.0001, + "sup_loss": 2.1982259592374884 + }, + { + "step": 1415, + "lr": 0.0001, + "sup_loss": 2.1983459305512563 + }, + { + "step": 1416, + "lr": 0.0001, + "sup_loss": 2.1981390063245985 + }, + { + "step": 1417, + "lr": 0.0001, + "sup_loss": 2.198286091269002 + }, + { + "step": 1418, + "lr": 0.0001, + "sup_loss": 2.1982575739543466 + }, + { + "step": 1419, + "lr": 0.0001, + "sup_loss": 2.1982988867726214 + }, + { + "step": 1420, + "lr": 0.0001, + "sup_loss": 2.19824844903215 + }, + { + "step": 1421, + "lr": 0.0001, + "sup_loss": 2.1982026503857846 + }, + { + "step": 1422, + "lr": 0.0001, + "sup_loss": 2.198284731430574 + }, + { + "step": 1423, + "lr": 0.0001, + "sup_loss": 2.1982188078378 + }, + { + "step": 1424, + "lr": 0.0001, + "sup_loss": 2.1981957382764876 + }, + { + "step": 1425, + "lr": 0.0001, + "sup_loss": 2.1983612003353246 + }, + { + "step": 1426, + "lr": 0.0001, + "sup_loss": 2.1982890971546576 + }, + { + "step": 1427, + "lr": 0.0001, + "sup_loss": 2.1982290958206496 + }, + { + "step": 1428, + "lr": 0.0001, + "sup_loss": 2.198284827716202 + }, + { + "step": 1429, + "lr": 0.0001, + "sup_loss": 2.198189284525286 + }, + { + "step": 1430, + "lr": 0.0001, + "sup_loss": 2.1982559637547254 + }, + { + "step": 1431, + "lr": 0.0001, + "sup_loss": 2.198239685043771 + }, + { + "step": 1432, + "lr": 0.0001, + "sup_loss": 2.1983038256817045 + }, + { + "step": 1433, + "lr": 0.0001, + "sup_loss": 2.1982736321546854 + }, + { + "step": 1434, + "lr": 0.0001, + "sup_loss": 2.19822817640869 + }, + { + "step": 1435, + "lr": 0.0001, + "sup_loss": 2.198302214960592 + }, + { + "step": 1436, + "lr": 0.0001, + "sup_loss": 2.198249042465063 + }, + { + "step": 1437, + "lr": 0.0001, + "sup_loss": 2.198290797269112 + }, + { + "step": 1438, + "lr": 0.0001, + "sup_loss": 2.1982584294096883 + }, + { + "step": 1439, + "lr": 0.0001, + "sup_loss": 2.198237079887546 + }, + { + "step": 1440, + "lr": 0.0001, + "sup_loss": 2.1981529965928823 + }, + { + "step": 1441, + "lr": 0.0001, + "sup_loss": 2.198252332487464 + }, + { + "step": 1442, + "lr": 0.0001, + "sup_loss": 2.198266573309584 + }, + { + "step": 1443, + "lr": 0.0001, + "sup_loss": 2.1982483419390686 + }, + { + "step": 1444, + "lr": 0.0001, + "sup_loss": 2.198301603519131 + }, + { + "step": 1445, + "lr": 0.0001, + "sup_loss": 2.1982194936251895 + }, + { + "step": 1446, + "lr": 0.0001, + "sup_loss": 2.1982742755003715 + }, + { + "step": 1447, + "lr": 0.0001, + "sup_loss": 2.198267233671202 + }, + { + "step": 1448, + "lr": 0.0001, + "sup_loss": 2.19825290950542 + }, + { + "step": 1449, + "lr": 0.0001, + "sup_loss": 2.1982260058232814 + }, + { + "step": 1450, + "lr": 0.0001, + "sup_loss": 2.198252236665218 + }, + { + "step": 1451, + "lr": 0.0001, + "sup_loss": 2.198264831994602 + }, + { + "step": 1452, + "lr": 0.0001, + "sup_loss": 2.1983202013021477 + }, + { + "step": 1453, + "lr": 0.0001, + "sup_loss": 2.1982181614270946 + }, + { + "step": 1454, + "lr": 0.0001, + "sup_loss": 2.198331543281976 + }, + { + "step": 1455, + "lr": 0.0001, + "sup_loss": 2.198306298708953 + }, + { + "step": 1456, + "lr": 0.0001, + "sup_loss": 2.198267224337383 + }, + { + "step": 1457, + "lr": 0.0001, + "sup_loss": 2.1981963293431033 + }, + { + "step": 1458, + "lr": 0.0001, + "sup_loss": 2.1982313960845827 + }, + { + "step": 1459, + "lr": 0.0001, + "sup_loss": 2.19829443850517 + }, + { + "step": 1460, + "lr": 0.0001, + "sup_loss": 2.198210636958674 + }, + { + "step": 1461, + "lr": 0.0001, + "sup_loss": 2.1982332631561783 + }, + { + "step": 1462, + "lr": 0.0001, + "sup_loss": 2.1982797534545933 + }, + { + "step": 1463, + "lr": 0.0001, + "sup_loss": 2.198227091899305 + }, + { + "step": 1464, + "lr": 0.0001, + "sup_loss": 2.1982068274028226 + }, + { + "step": 1465, + "lr": 0.0001, + "sup_loss": 2.1982329710478785 + }, + { + "step": 1466, + "lr": 0.0001, + "sup_loss": 2.1981586217308924 + }, + { + "step": 1467, + "lr": 0.0001, + "sup_loss": 2.198211498225635 + }, + { + "step": 1468, + "lr": 0.0001, + "sup_loss": 2.198182093684288 + }, + { + "step": 1469, + "lr": 0.0001, + "sup_loss": 2.198242690691697 + }, + { + "step": 1470, + "lr": 0.0001, + "sup_loss": 2.1982453175261942 + }, + { + "step": 1471, + "lr": 0.0001, + "sup_loss": 2.198165973430081 + }, + { + "step": 1472, + "lr": 0.0001, + "sup_loss": 2.198322630286552 + }, + { + "step": 1473, + "lr": 0.0001, + "sup_loss": 2.1981794895720657 + }, + { + "step": 1474, + "lr": 0.0001, + "sup_loss": 2.1982177409585173 + }, + { + "step": 1475, + "lr": 0.0001, + "sup_loss": 2.198215694949055 + }, + { + "step": 1476, + "lr": 0.0001, + "sup_loss": 2.198151321625174 + }, + { + "step": 1477, + "lr": 0.0001, + "sup_loss": 2.1982850803199465 + }, + { + "step": 1478, + "lr": 0.0001, + "sup_loss": 2.198154038281344 + }, + { + "step": 1479, + "lr": 0.0001, + "sup_loss": 2.1981560678532395 + }, + { + "step": 1480, + "lr": 0.0001, + "sup_loss": 2.1981195517722645 + }, + { + "step": 1481, + "lr": 0.0001, + "sup_loss": 2.1981342958743544 + }, + { + "step": 1482, + "lr": 0.0001, + "sup_loss": 2.198149839223092 + }, + { + "step": 1483, + "lr": 0.0001, + "sup_loss": 2.198077623604559 + }, + { + "step": 1484, + "lr": 0.0001, + "sup_loss": 2.1981879483768845 + }, + { + "step": 1485, + "lr": 0.0001, + "sup_loss": 2.198165773900442 + }, + { + "step": 1486, + "lr": 0.0001, + "sup_loss": 2.1981879810994975 + }, + { + "step": 1487, + "lr": 0.0001, + "sup_loss": 2.198076709880473 + }, + { + "step": 1488, + "lr": 0.0001, + "sup_loss": 2.1981967996694363 + }, + { + "step": 1489, + "lr": 0.0001, + "sup_loss": 2.1981373084003755 + }, + { + "step": 1490, + "lr": 0.0001, + "sup_loss": 2.198165752864003 + }, + { + "step": 1491, + "lr": 0.0001, + "sup_loss": 2.1982042675416484 + }, + { + "step": 1492, + "lr": 0.0001, + "sup_loss": 2.1981680704380677 + }, + { + "step": 1493, + "lr": 0.0001, + "sup_loss": 2.1981536632034167 + }, + { + "step": 1494, + "lr": 0.0001, + "sup_loss": 2.1981297851792 + }, + { + "step": 1495, + "lr": 0.0001, + "sup_loss": 2.198245155117621 + }, + { + "step": 1496, + "lr": 0.0001, + "sup_loss": 2.198164620354203 + }, + { + "step": 1497, + "lr": 0.0001, + "sup_loss": 2.1981274321189126 + }, + { + "step": 1498, + "lr": 0.0001, + "sup_loss": 2.1980881297317927 + }, + { + "step": 1499, + "lr": 0.0001, + "sup_loss": 2.1980534242693843 + }, + { + "step": 1500, + "lr": 0.0001, + "sup_loss": 2.1980902737736505 + }, + { + "step": 1501, + "lr": 0.0001, + "sup_loss": 2.1981033986652796 + }, + { + "step": 1502, + "lr": 0.0001, + "sup_loss": 2.1980217225536904 + }, + { + "step": 1503, + "lr": 0.0001, + "sup_loss": 2.1980745183077404 + }, + { + "step": 1504, + "lr": 0.0001, + "sup_loss": 2.198104462922978 + }, + { + "step": 1505, + "lr": 0.0001, + "sup_loss": 2.1981365681912197 + }, + { + "step": 1506, + "lr": 0.0001, + "sup_loss": 2.198052349584146 + }, + { + "step": 1507, + "lr": 0.0001, + "sup_loss": 2.1981053411323623 + }, + { + "step": 1508, + "lr": 0.0001, + "sup_loss": 2.1980829128795696 + }, + { + "step": 1509, + "lr": 0.0001, + "sup_loss": 2.1980937828284453 + }, + { + "step": 1510, + "lr": 0.0001, + "sup_loss": 2.1980795857377635 + }, + { + "step": 1511, + "lr": 0.0001, + "sup_loss": 2.198053977732459 + }, + { + "step": 1512, + "lr": 0.0001, + "sup_loss": 2.198080727103811 + }, + { + "step": 1513, + "lr": 0.0001, + "sup_loss": 2.1981790649876647 + }, + { + "step": 1514, + "lr": 0.0001, + "sup_loss": 2.1980826620270535 + }, + { + "step": 1515, + "lr": 0.0001, + "sup_loss": 2.1980531424817364 + }, + { + "step": 1516, + "lr": 0.0001, + "sup_loss": 2.1980679474089158 + }, + { + "step": 1517, + "lr": 0.0001, + "sup_loss": 2.198068413398884 + }, + { + "step": 1518, + "lr": 0.0001, + "sup_loss": 2.1981563810776246 + }, + { + "step": 1519, + "lr": 0.0001, + "sup_loss": 2.198049509936044 + }, + { + "step": 1520, + "lr": 0.0001, + "sup_loss": 2.1981579710181944 + }, + { + "step": 1521, + "lr": 0.0001, + "sup_loss": 2.1980820819375086 + }, + { + "step": 1522, + "lr": 0.0001, + "sup_loss": 2.19799094523962 + }, + { + "step": 1523, + "lr": 0.0001, + "sup_loss": 2.1980436997976325 + }, + { + "step": 1524, + "lr": 0.0001, + "sup_loss": 2.198044385736006 + }, + { + "step": 1525, + "lr": 0.0001, + "sup_loss": 2.198005066004658 + }, + { + "step": 1526, + "lr": 0.0001, + "sup_loss": 2.198048792391058 + }, + { + "step": 1527, + "lr": 0.0001, + "sup_loss": 2.198049390964888 + }, + { + "step": 1528, + "lr": 0.0001, + "sup_loss": 2.1980154709501787 + }, + { + "step": 1529, + "lr": 0.0001, + "sup_loss": 2.198010932464648 + }, + { + "step": 1530, + "lr": 0.0001, + "sup_loss": 2.198054374524364 + }, + { + "step": 1531, + "lr": 0.0001, + "sup_loss": 2.1980621294964964 + }, + { + "step": 1532, + "lr": 0.0001, + "sup_loss": 2.198068910060968 + }, + { + "step": 1533, + "lr": 0.0001, + "sup_loss": 2.198157895285002 + }, + { + "step": 1534, + "lr": 0.0001, + "sup_loss": 2.1980161519992243 + }, + { + "step": 1535, + "lr": 0.0001, + "sup_loss": 2.198106222818936 + }, + { + "step": 1536, + "lr": 0.0001, + "sup_loss": 2.1979899213650995 + }, + { + "step": 1537, + "lr": 0.0001, + "sup_loss": 2.1980156146388192 + }, + { + "step": 1538, + "lr": 0.0001, + "sup_loss": 2.1980462690875187 + }, + { + "step": 1539, + "lr": 0.0001, + "sup_loss": 2.1979841644321794 + }, + { + "step": 1540, + "lr": 0.0001, + "sup_loss": 2.198149160739046 + }, + { + "step": 1541, + "lr": 0.0001, + "sup_loss": 2.1980869157027483 + }, + { + "step": 1542, + "lr": 0.0001, + "sup_loss": 2.19811382151477 + }, + { + "step": 1543, + "lr": 0.0001, + "sup_loss": 2.198063187167833 + }, + { + "step": 1544, + "lr": 0.0001, + "sup_loss": 2.1980124025872807 + }, + { + "step": 1545, + "lr": 0.0001, + "sup_loss": 2.198009989075995 + }, + { + "step": 1546, + "lr": 0.0001, + "sup_loss": 2.1981011151224337 + }, + { + "step": 1547, + "lr": 0.0001, + "sup_loss": 2.198047364510459 + }, + { + "step": 1548, + "lr": 0.0001, + "sup_loss": 2.1980094261741145 + }, + { + "step": 1549, + "lr": 0.0001, + "sup_loss": 2.198034084700465 + }, + { + "step": 1550, + "lr": 0.0001, + "sup_loss": 2.1980591844230486 + }, + { + "step": 1551, + "lr": 0.0001, + "sup_loss": 2.1981549572508357 + }, + { + "step": 1552, + "lr": 0.0001, + "sup_loss": 2.19813047672303 + }, + { + "step": 1553, + "lr": 0.0001, + "sup_loss": 2.1980730348077815 + }, + { + "step": 1554, + "lr": 0.0001, + "sup_loss": 2.198090194491478 + }, + { + "step": 1555, + "lr": 0.0001, + "sup_loss": 2.1980929185000995 + }, + { + "step": 1556, + "lr": 0.0001, + "sup_loss": 2.1981211642717016 + }, + { + "step": 1557, + "lr": 0.0001, + "sup_loss": 2.19810762074555 + }, + { + "step": 1558, + "lr": 0.0001, + "sup_loss": 2.1980665339353713 + }, + { + "step": 1559, + "lr": 0.0001, + "sup_loss": 2.1981333653024695 + }, + { + "step": 1560, + "lr": 0.0001, + "sup_loss": 2.1981042208802335 + }, + { + "step": 1561, + "lr": 0.0001, + "sup_loss": 2.198047218129166 + }, + { + "step": 1562, + "lr": 0.0001, + "sup_loss": 2.1980256771380553 + }, + { + "step": 1563, + "lr": 0.0001, + "sup_loss": 2.1979855153158754 + }, + { + "step": 1564, + "lr": 0.0001, + "sup_loss": 2.19806702743183 + }, + { + "step": 1565, + "lr": 0.0001, + "sup_loss": 2.1981334659087093 + }, + { + "step": 1566, + "lr": 0.0001, + "sup_loss": 2.1980971814525043 + }, + { + "step": 1567, + "lr": 0.0001, + "sup_loss": 2.1981075094702733 + }, + { + "step": 1568, + "lr": 0.0001, + "sup_loss": 2.198118589006948 + }, + { + "step": 1569, + "lr": 0.0001, + "sup_loss": 2.198031236830476 + }, + { + "step": 1570, + "lr": 0.0001, + "sup_loss": 2.1981129251168077 + }, + { + "step": 1571, + "lr": 0.0001, + "sup_loss": 2.1980141092574557 + }, + { + "step": 1572, + "lr": 0.0001, + "sup_loss": 2.198164880300382 + }, + { + "step": 1573, + "lr": 0.0001, + "sup_loss": 2.198124862574475 + }, + { + "step": 1574, + "lr": 0.0001, + "sup_loss": 2.198112114247979 + }, + { + "step": 1575, + "lr": 0.0001, + "sup_loss": 2.198105727577541 + }, + { + "step": 1576, + "lr": 0.0001, + "sup_loss": 2.19812541509697 + }, + { + "step": 1577, + "lr": 0.0001, + "sup_loss": 2.198018325471063 + }, + { + "step": 1578, + "lr": 0.0001, + "sup_loss": 2.1980813523357114 + }, + { + "step": 1579, + "lr": 0.0001, + "sup_loss": 2.1981372530105863 + }, + { + "step": 1580, + "lr": 0.0001, + "sup_loss": 2.1981103093321814 + }, + { + "step": 1581, + "lr": 0.0001, + "sup_loss": 2.1980368368086394 + }, + { + "step": 1582, + "lr": 0.0001, + "sup_loss": 2.1981039890195486 + }, + { + "step": 1583, + "lr": 0.0001, + "sup_loss": 2.1980579016892983 + }, + { + "step": 1584, + "lr": 0.0001, + "sup_loss": 2.198123282796446 + }, + { + "step": 1585, + "lr": 0.0001, + "sup_loss": 2.1981348769592186 + }, + { + "step": 1586, + "lr": 0.0001, + "sup_loss": 2.1981008333717513 + }, + { + "step": 1587, + "lr": 0.0001, + "sup_loss": 2.198114380001711 + }, + { + "step": 1588, + "lr": 0.0001, + "sup_loss": 2.1980330168967726 + }, + { + "step": 1589, + "lr": 0.0001, + "sup_loss": 2.198024118424863 + }, + { + "step": 1590, + "lr": 0.0001, + "sup_loss": 2.198060051350918 + }, + { + "step": 1591, + "lr": 0.0001, + "sup_loss": 2.1980787434111857 + }, + { + "step": 1592, + "lr": 0.0001, + "sup_loss": 2.1981216332764912 + }, + { + "step": 1593, + "lr": 0.0001, + "sup_loss": 2.1981823785823242 + }, + { + "step": 1594, + "lr": 0.0001, + "sup_loss": 2.1981253965477796 + }, + { + "step": 1595, + "lr": 0.0001, + "sup_loss": 2.1981623234695222 + }, + { + "step": 1596, + "lr": 0.0001, + "sup_loss": 2.1981150778851433 + }, + { + "step": 1597, + "lr": 0.0001, + "sup_loss": 2.197989677264907 + }, + { + "step": 1598, + "lr": 0.0001, + "sup_loss": 2.1980381313686874 + }, + { + "step": 1599, + "lr": 0.0001, + "sup_loss": 2.197999258617638 + }, + { + "step": 1600, + "lr": 0.0001, + "sup_loss": 2.198089000600042 + }, + { + "step": 1601, + "lr": 0.0001, + "sup_loss": 2.198023719834417 + }, + { + "step": 1602, + "lr": 0.0001, + "sup_loss": 2.1979968685689713 + }, + { + "step": 1603, + "lr": 0.0001, + "sup_loss": 2.198092733003998 + }, + { + "step": 1604, + "lr": 0.0001, + "sup_loss": 2.198035978836314 + }, + { + "step": 1605, + "lr": 0.0001, + "sup_loss": 2.1980483646042734 + }, + { + "step": 1606, + "lr": 0.0001, + "sup_loss": 2.1980586212160462 + }, + { + "step": 1607, + "lr": 0.0001, + "sup_loss": 2.1980673305113907 + }, + { + "step": 1608, + "lr": 0.0001, + "sup_loss": 2.1980511747031457 + }, + { + "step": 1609, + "lr": 0.0001, + "sup_loss": 2.1980667127113698 + }, + { + "step": 1610, + "lr": 0.0001, + "sup_loss": 2.198065251427237 + }, + { + "step": 1611, + "lr": 0.0001, + "sup_loss": 2.1980485664591 + }, + { + "step": 1612, + "lr": 0.0001, + "sup_loss": 2.1979729431440567 + }, + { + "step": 1613, + "lr": 0.0001, + "sup_loss": 2.198008242361113 + }, + { + "step": 1614, + "lr": 0.0001, + "sup_loss": 2.1980723273736755 + }, + { + "step": 1615, + "lr": 0.0001, + "sup_loss": 2.1980270486596725 + }, + { + "step": 1616, + "lr": 0.0001, + "sup_loss": 2.1980842002458525 + }, + { + "step": 1617, + "lr": 0.0001, + "sup_loss": 2.198057560233968 + }, + { + "step": 1618, + "lr": 0.0001, + "sup_loss": 2.198023965341036 + }, + { + "step": 1619, + "lr": 0.0001, + "sup_loss": 2.1980420205884 + }, + { + "step": 1620, + "lr": 0.0001, + "sup_loss": 2.198020813585975 + }, + { + "step": 1621, + "lr": 0.0001, + "sup_loss": 2.198054934115483 + }, + { + "step": 1622, + "lr": 0.0001, + "sup_loss": 2.198031987061097 + }, + { + "step": 1623, + "lr": 0.0001, + "sup_loss": 2.1980004000547178 + }, + { + "step": 1624, + "lr": 0.0001, + "sup_loss": 2.198013967741659 + }, + { + "step": 1625, + "lr": 0.0001, + "sup_loss": 2.1980269586885592 + }, + { + "step": 1626, + "lr": 0.0001, + "sup_loss": 2.1979153652214767 + }, + { + "step": 1627, + "lr": 0.0001, + "sup_loss": 2.1979546645764367 + }, + { + "step": 1628, + "lr": 0.0001, + "sup_loss": 2.1980374006018604 + }, + { + "step": 1629, + "lr": 0.0001, + "sup_loss": 2.1979788973508767 + }, + { + "step": 1630, + "lr": 0.0001, + "sup_loss": 2.1980093344394387 + }, + { + "step": 1631, + "lr": 0.0001, + "sup_loss": 2.1980255583687622 + }, + { + "step": 1632, + "lr": 0.0001, + "sup_loss": 2.197987595942893 + }, + { + "step": 1633, + "lr": 0.0001, + "sup_loss": 2.1980112999956747 + }, + { + "step": 1634, + "lr": 0.0001, + "sup_loss": 2.1979432522783693 + }, + { + "step": 1635, + "lr": 0.0001, + "sup_loss": 2.198086523952517 + }, + { + "step": 1636, + "lr": 0.0001, + "sup_loss": 2.197985354880363 + }, + { + "step": 1637, + "lr": 0.0001, + "sup_loss": 2.198048610416235 + }, + { + "step": 1638, + "lr": 0.0001, + "sup_loss": 2.1980162406215085 + }, + { + "step": 1639, + "lr": 0.0001, + "sup_loss": 2.1980358985850756 + }, + { + "step": 1640, + "lr": 0.0001, + "sup_loss": 2.198073328775058 + }, + { + "step": 1641, + "lr": 0.0001, + "sup_loss": 2.1979762319896627 + }, + { + "step": 1642, + "lr": 0.0001, + "sup_loss": 2.197996698482325 + }, + { + "step": 1643, + "lr": 0.0001, + "sup_loss": 2.1979274868353653 + }, + { + "step": 1644, + "lr": 0.0001, + "sup_loss": 2.1980205022186943 + }, + { + "step": 1645, + "lr": 0.0001, + "sup_loss": 2.1980011744139865 + }, + { + "step": 1646, + "lr": 0.0001, + "sup_loss": 2.197978635114295 + }, + { + "step": 1647, + "lr": 0.0001, + "sup_loss": 2.1979728207654743 + }, + { + "step": 1648, + "lr": 0.0001, + "sup_loss": 2.1979285045975634 + }, + { + "step": 1649, + "lr": 0.0001, + "sup_loss": 2.198020161492067 + }, + { + "step": 1650, + "lr": 0.0001, + "sup_loss": 2.1979165449063327 + }, + { + "step": 1651, + "lr": 0.0001, + "sup_loss": 2.1979554279951223 + }, + { + "step": 1652, + "lr": 0.0001, + "sup_loss": 2.1980127336719093 + }, + { + "step": 1653, + "lr": 0.0001, + "sup_loss": 2.1979946992469706 + }, + { + "step": 1654, + "lr": 0.0001, + "sup_loss": 2.1979411268638547 + }, + { + "step": 1655, + "lr": 0.0001, + "sup_loss": 2.197910815024314 + }, + { + "step": 1656, + "lr": 0.0001, + "sup_loss": 2.1979872384731034 + }, + { + "step": 1657, + "lr": 0.0001, + "sup_loss": 2.1979530278211294 + }, + { + "step": 1658, + "lr": 0.0001, + "sup_loss": 2.197877925179947 + }, + { + "step": 1659, + "lr": 0.0001, + "sup_loss": 2.1979778868946562 + }, + { + "step": 1660, + "lr": 0.0001, + "sup_loss": 2.1980834296698566 + }, + { + "step": 1661, + "lr": 0.0001, + "sup_loss": 2.197927381008257 + }, + { + "step": 1662, + "lr": 0.0001, + "sup_loss": 2.1979606290907325 + }, + { + "step": 1663, + "lr": 0.0001, + "sup_loss": 2.197919697957658 + }, + { + "step": 1664, + "lr": 0.0001, + "sup_loss": 2.1980036309898834 + }, + { + "step": 1665, + "lr": 0.0001, + "sup_loss": 2.1979610086942696 + }, + { + "step": 1666, + "lr": 0.0001, + "sup_loss": 2.1979127782012937 + }, + { + "step": 1667, + "lr": 0.0001, + "sup_loss": 2.197947950468901 + }, + { + "step": 1668, + "lr": 0.0001, + "sup_loss": 2.197883143930745 + }, + { + "step": 1669, + "lr": 0.0001, + "sup_loss": 2.197901057721708 + }, + { + "step": 1670, + "lr": 0.0001, + "sup_loss": 2.19795841875071 + }, + { + "step": 1671, + "lr": 0.0001, + "sup_loss": 2.197988090750454 + }, + { + "step": 1672, + "lr": 0.0001, + "sup_loss": 2.1979330259458423 + }, + { + "step": 1673, + "lr": 0.0001, + "sup_loss": 2.1979215557084038 + }, + { + "step": 1674, + "lr": 0.0001, + "sup_loss": 2.19791087362941 + }, + { + "step": 1675, + "lr": 0.0001, + "sup_loss": 2.1979534689755633 + }, + { + "step": 1676, + "lr": 0.0001, + "sup_loss": 2.1979513538157884 + }, + { + "step": 1677, + "lr": 0.0001, + "sup_loss": 2.1978699300887685 + }, + { + "step": 1678, + "lr": 0.0001, + "sup_loss": 2.1979271543680348 + }, + { + "step": 1679, + "lr": 0.0001, + "sup_loss": 2.19791135942664 + }, + { + "step": 1680, + "lr": 0.0001, + "sup_loss": 2.1979127700089567 + }, + { + "step": 1681, + "lr": 0.0001, + "sup_loss": 2.1979309497627932 + }, + { + "step": 1682, + "lr": 0.0001, + "sup_loss": 2.197924089863551 + }, + { + "step": 1683, + "lr": 0.0001, + "sup_loss": 2.198035410821715 + }, + { + "step": 1684, + "lr": 0.0001, + "sup_loss": 2.1979647291399678 + }, + { + "step": 1685, + "lr": 0.0001, + "sup_loss": 2.1979766241756753 + }, + { + "step": 1686, + "lr": 0.0001, + "sup_loss": 2.197964469373305 + }, + { + "step": 1687, + "lr": 0.0001, + "sup_loss": 2.197899813356653 + }, + { + "step": 1688, + "lr": 0.0001, + "sup_loss": 2.1979451323205534 + }, + { + "step": 1689, + "lr": 0.0001, + "sup_loss": 2.198012739121976 + }, + { + "step": 1690, + "lr": 0.0001, + "sup_loss": 2.197910029955911 + }, + { + "step": 1691, + "lr": 0.0001, + "sup_loss": 2.197854432555358 + }, + { + "step": 1692, + "lr": 0.0001, + "sup_loss": 2.197851299720093 + }, + { + "step": 1693, + "lr": 0.0001, + "sup_loss": 2.1979530558958693 + }, + { + "step": 1694, + "lr": 0.0001, + "sup_loss": 2.1979151180776517 + }, + { + "step": 1695, + "lr": 0.0001, + "sup_loss": 2.1979640079989595 + }, + { + "step": 1696, + "lr": 0.0001, + "sup_loss": 2.197956614329293 + }, + { + "step": 1697, + "lr": 0.0001, + "sup_loss": 2.197971761983198 + }, + { + "step": 1698, + "lr": 0.0001, + "sup_loss": 2.1978840226189233 + }, + { + "step": 1699, + "lr": 0.0001, + "sup_loss": 2.197923294098128 + }, + { + "step": 1700, + "lr": 0.0001, + "sup_loss": 2.198034698334716 + }, + { + "step": 1701, + "lr": 0.0001, + "sup_loss": 2.197984846419505 + }, + { + "step": 1702, + "lr": 0.0001, + "sup_loss": 2.197954893863348 + }, + { + "step": 1703, + "lr": 0.0001, + "sup_loss": 2.1979412308630395 + }, + { + "step": 1704, + "lr": 0.0001, + "sup_loss": 2.197854460577592 + }, + { + "step": 1705, + "lr": 0.0001, + "sup_loss": 2.1979166043126765 + }, + { + "step": 1706, + "lr": 0.0001, + "sup_loss": 2.197936220910242 + }, + { + "step": 1707, + "lr": 0.0001, + "sup_loss": 2.197918318659589 + }, + { + "step": 1708, + "lr": 0.0001, + "sup_loss": 2.1979361312916765 + }, + { + "step": 1709, + "lr": 0.0001, + "sup_loss": 2.197901230922019 + }, + { + "step": 1710, + "lr": 0.0001, + "sup_loss": 2.1979296645252564 + }, + { + "step": 1711, + "lr": 0.0001, + "sup_loss": 2.197962185564658 + }, + { + "step": 1712, + "lr": 0.0001, + "sup_loss": 2.197952922760418 + }, + { + "step": 1713, + "lr": 0.0001, + "sup_loss": 2.197903376071055 + }, + { + "step": 1714, + "lr": 0.0001, + "sup_loss": 2.1979730799836372 + }, + { + "step": 1715, + "lr": 0.0001, + "sup_loss": 2.197909250714136 + }, + { + "step": 1716, + "lr": 0.0001, + "sup_loss": 2.1979288873013774 + }, + { + "step": 1717, + "lr": 0.0001, + "sup_loss": 2.1978844302127176 + }, + { + "step": 1718, + "lr": 0.0001, + "sup_loss": 2.1979539002509796 + }, + { + "step": 1719, + "lr": 0.0001, + "sup_loss": 2.19787174221326 + }, + { + "step": 1720, + "lr": 0.0001, + "sup_loss": 2.197887435131304 + }, + { + "step": 1721, + "lr": 0.0001, + "sup_loss": 2.1978676650798623 + }, + { + "step": 1722, + "lr": 0.0001, + "sup_loss": 2.1979371208933287 + }, + { + "step": 1723, + "lr": 0.0001, + "sup_loss": 2.1978968138989536 + }, + { + "step": 1724, + "lr": 0.0001, + "sup_loss": 2.1978986358827233 + }, + { + "step": 1725, + "lr": 0.0001, + "sup_loss": 2.197952952866526 + }, + { + "step": 1726, + "lr": 0.0001, + "sup_loss": 2.197882629929565 + }, + { + "step": 1727, + "lr": 0.0001, + "sup_loss": 2.1978917599094605 + }, + { + "step": 1728, + "lr": 0.0001, + "sup_loss": 2.1979110785243767 + }, + { + "step": 1729, + "lr": 0.0001, + "sup_loss": 2.1979087131376223 + }, + { + "step": 1730, + "lr": 0.0001, + "sup_loss": 2.197909592119051 + }, + { + "step": 1731, + "lr": 0.0001, + "sup_loss": 2.1978750452332174 + }, + { + "step": 1732, + "lr": 0.0001, + "sup_loss": 2.1979506578149475 + }, + { + "step": 1733, + "lr": 0.0001, + "sup_loss": 2.1979420080137353 + }, + { + "step": 1734, + "lr": 0.0001, + "sup_loss": 2.1978272498261795 + }, + { + "step": 1735, + "lr": 0.0001, + "sup_loss": 2.197897861484492 + }, + { + "step": 1736, + "lr": 0.0001, + "sup_loss": 2.197883847393703 + }, + { + "step": 1737, + "lr": 0.0001, + "sup_loss": 2.1979126564856792 + }, + { + "step": 1738, + "lr": 0.0001, + "sup_loss": 2.1979122413956422 + }, + { + "step": 1739, + "lr": 0.0001, + "sup_loss": 2.1979088717773823 + }, + { + "step": 1740, + "lr": 0.0001, + "sup_loss": 2.1978699704123925 + }, + { + "step": 1741, + "lr": 0.0001, + "sup_loss": 2.1979056632375062 + }, + { + "step": 1742, + "lr": 0.0001, + "sup_loss": 2.197800053756945 + }, + { + "step": 1743, + "lr": 0.0001, + "sup_loss": 2.197879435815199 + }, + { + "step": 1744, + "lr": 0.0001, + "sup_loss": 2.1979409755611248 + }, + { + "step": 1745, + "lr": 0.0001, + "sup_loss": 2.1979626263080267 + }, + { + "step": 1746, + "lr": 0.0001, + "sup_loss": 2.197801357941252 + }, + { + "step": 1747, + "lr": 0.0001, + "sup_loss": 2.1978890548562173 + }, + { + "step": 1748, + "lr": 0.0001, + "sup_loss": 2.197893468601057 + }, + { + "step": 1749, + "lr": 0.0001, + "sup_loss": 2.1978902650115515 + }, + { + "step": 1750, + "lr": 0.0001, + "sup_loss": 2.1979126294310083 + }, + { + "step": 1751, + "lr": 0.0001, + "sup_loss": 2.1978468781888973 + }, + { + "step": 1752, + "lr": 0.0001, + "sup_loss": 2.1978907646938395 + }, + { + "step": 1753, + "lr": 0.0001, + "sup_loss": 2.1979290950364945 + }, + { + "step": 1754, + "lr": 0.0001, + "sup_loss": 2.1978989060097147 + }, + { + "step": 1755, + "lr": 0.0001, + "sup_loss": 2.197860999207074 + }, + { + "step": 1756, + "lr": 0.0001, + "sup_loss": 2.1978863079042266 + }, + { + "step": 1757, + "lr": 0.0001, + "sup_loss": 2.1979319631684633 + }, + { + "step": 1758, + "lr": 0.0001, + "sup_loss": 2.1978519678101605 + }, + { + "step": 1759, + "lr": 0.0001, + "sup_loss": 2.197904364137977 + }, + { + "step": 1760, + "lr": 0.0001, + "sup_loss": 2.197862780118205 + }, + { + "step": 1761, + "lr": 0.0001, + "sup_loss": 2.1978977831038438 + }, + { + "step": 1762, + "lr": 0.0001, + "sup_loss": 2.197833351478134 + }, + { + "step": 1763, + "lr": 0.0001, + "sup_loss": 2.197877347894761 + }, + { + "step": 1764, + "lr": 0.0001, + "sup_loss": 2.1978548236894198 + }, + { + "step": 1765, + "lr": 0.0001, + "sup_loss": 2.197821247992262 + }, + { + "step": 1766, + "lr": 0.0001, + "sup_loss": 2.1978378268515026 + }, + { + "step": 1767, + "lr": 0.0001, + "sup_loss": 2.1978738872408483 + }, + { + "step": 1768, + "lr": 0.0001, + "sup_loss": 2.197885267413181 + }, + { + "step": 1769, + "lr": 0.0001, + "sup_loss": 2.19783525544698 + }, + { + "step": 1770, + "lr": 0.0001, + "sup_loss": 2.197870761558439 + }, + { + "step": 1771, + "lr": 0.0001, + "sup_loss": 2.197819668520334 + }, + { + "step": 1772, + "lr": 0.0001, + "sup_loss": 2.1978248851095277 + }, + { + "step": 1773, + "lr": 0.0001, + "sup_loss": 2.1977843568571 + }, + { + "step": 1774, + "lr": 0.0001, + "sup_loss": 2.197832396119286 + }, + { + "step": 1775, + "lr": 0.0001, + "sup_loss": 2.1978168536914 + }, + { + "step": 1776, + "lr": 0.0001, + "sup_loss": 2.197841410761149 + }, + { + "step": 1777, + "lr": 0.0001, + "sup_loss": 2.1978584982085168 + }, + { + "step": 1778, + "lr": 0.0001, + "sup_loss": 2.197778713259485 + }, + { + "step": 1779, + "lr": 0.0001, + "sup_loss": 2.1978314206397145 + }, + { + "step": 1780, + "lr": 0.0001, + "sup_loss": 2.1978777288173448 + }, + { + "step": 1781, + "lr": 0.0001, + "sup_loss": 2.1978237580342634 + }, + { + "step": 1782, + "lr": 0.0001, + "sup_loss": 2.1978568596035344 + }, + { + "step": 1783, + "lr": 0.0001, + "sup_loss": 2.1978512103418173 + }, + { + "step": 1784, + "lr": 0.0001, + "sup_loss": 2.197835547271449 + }, + { + "step": 1785, + "lr": 0.0001, + "sup_loss": 2.1978792535472067 + }, + { + "step": 1786, + "lr": 0.0001, + "sup_loss": 2.1978746906301394 + }, + { + "step": 1787, + "lr": 0.0001, + "sup_loss": 2.1978399702497455 + }, + { + "step": 1788, + "lr": 0.0001, + "sup_loss": 2.197816885496166 + }, + { + "step": 1789, + "lr": 0.0001, + "sup_loss": 2.1978651919094454 + }, + { + "step": 1790, + "lr": 0.0001, + "sup_loss": 2.1978429511297692 + }, + { + "step": 1791, + "lr": 0.0001, + "sup_loss": 2.197782977517546 + }, + { + "step": 1792, + "lr": 0.0001, + "sup_loss": 2.1978368190570903 + }, + { + "step": 1793, + "lr": 0.0001, + "sup_loss": 2.197866974600221 + }, + { + "step": 1794, + "lr": 0.0001, + "sup_loss": 2.197861219011796 + }, + { + "step": 1795, + "lr": 0.0001, + "sup_loss": 2.1978807708401393 + }, + { + "step": 1796, + "lr": 0.0001, + "sup_loss": 2.197857062126995 + }, + { + "step": 1797, + "lr": 0.0001, + "sup_loss": 2.1978420273465407 + }, + { + "step": 1798, + "lr": 0.0001, + "sup_loss": 2.197877871277167 + }, + { + "step": 1799, + "lr": 0.0001, + "sup_loss": 2.1978454436827386 + }, + { + "step": 1800, + "lr": 0.0001, + "sup_loss": 2.1978094738486673 + }, + { + "step": 1801, + "lr": 0.0001, + "sup_loss": 2.1978136326314974 + }, + { + "step": 1802, + "lr": 0.0001, + "sup_loss": 2.19788053247365 + }, + { + "step": 1803, + "lr": 0.0001, + "sup_loss": 2.1977596560549038 + }, + { + "step": 1804, + "lr": 0.0001, + "sup_loss": 2.1978176015347515 + }, + { + "step": 1805, + "lr": 0.0001, + "sup_loss": 2.1978420393456695 + }, + { + "step": 1806, + "lr": 0.0001, + "sup_loss": 2.1977668204217315 + }, + { + "step": 1807, + "lr": 0.0001, + "sup_loss": 2.197759433071028 + }, + { + "step": 1808, + "lr": 0.0001, + "sup_loss": 2.197759321611811 + }, + { + "step": 1809, + "lr": 0.0001, + "sup_loss": 2.197747458924812 + }, + { + "step": 1810, + "lr": 0.0001, + "sup_loss": 2.1977558753036552 + }, + { + "step": 1811, + "lr": 0.0001, + "sup_loss": 2.1977879045809523 + }, + { + "step": 1812, + "lr": 0.0001, + "sup_loss": 2.197761618570626 + }, + { + "step": 1813, + "lr": 0.0001, + "sup_loss": 2.19772030804323 + }, + { + "step": 1814, + "lr": 0.0001, + "sup_loss": 2.1977515222639985 + }, + { + "step": 1815, + "lr": 0.0001, + "sup_loss": 2.197723285568781 + }, + { + "step": 1816, + "lr": 0.0001, + "sup_loss": 2.1977549894082613 + }, + { + "step": 1817, + "lr": 0.0001, + "sup_loss": 2.197815194353421 + }, + { + "step": 1818, + "lr": 0.0001, + "sup_loss": 2.197772526110036 + }, + { + "step": 1819, + "lr": 0.0001, + "sup_loss": 2.1978170258755245 + }, + { + "step": 1820, + "lr": 0.0001, + "sup_loss": 2.197726828958985 + }, + { + "step": 1821, + "lr": 0.0001, + "sup_loss": 2.1977261049729773 + }, + { + "step": 1822, + "lr": 0.0001, + "sup_loss": 2.19773705741606 + }, + { + "step": 1823, + "lr": 0.0001, + "sup_loss": 2.197762965126041 + }, + { + "step": 1824, + "lr": 0.0001, + "sup_loss": 2.197749149053088 + }, + { + "step": 1825, + "lr": 0.0001, + "sup_loss": 2.1977379490404028 + }, + { + "step": 1826, + "lr": 0.0001, + "sup_loss": 2.197799995064332 + }, + { + "step": 1827, + "lr": 0.0001, + "sup_loss": 2.1977758791925064 + }, + { + "step": 1828, + "lr": 0.0001, + "sup_loss": 2.1977843264731947 + }, + { + "step": 1829, + "lr": 0.0001, + "sup_loss": 2.197753231753335 + }, + { + "step": 1830, + "lr": 0.0001, + "sup_loss": 2.197822673478526 + }, + { + "step": 1831, + "lr": 0.0001, + "sup_loss": 2.1977730841135457 + }, + { + "step": 1832, + "lr": 0.0001, + "sup_loss": 2.197686835987915 + }, + { + "step": 1833, + "lr": 0.0001, + "sup_loss": 2.1977056560048593 + }, + { + "step": 1834, + "lr": 0.0001, + "sup_loss": 2.197718086594156 + }, + { + "step": 1835, + "lr": 0.0001, + "sup_loss": 2.1978146096081836 + }, + { + "step": 1836, + "lr": 0.0001, + "sup_loss": 2.197723155877461 + }, + { + "step": 1837, + "lr": 0.0001, + "sup_loss": 2.1977018997830298 + }, + { + "step": 1838, + "lr": 0.0001, + "sup_loss": 2.1976756663919477 + }, + { + "step": 1839, + "lr": 0.0001, + "sup_loss": 2.197737606293683 + }, + { + "step": 1840, + "lr": 0.0001, + "sup_loss": 2.1977435120632056 + }, + { + "step": 1841, + "lr": 0.0001, + "sup_loss": 2.1977185749936123 + }, + { + "step": 1842, + "lr": 0.0001, + "sup_loss": 2.197742920814254 + }, + { + "step": 1843, + "lr": 0.0001, + "sup_loss": 2.1977618071933147 + }, + { + "step": 1844, + "lr": 0.0001, + "sup_loss": 2.1977867240370665 + }, + { + "step": 1845, + "lr": 0.0001, + "sup_loss": 2.197712159384353 + }, + { + "step": 1846, + "lr": 0.0001, + "sup_loss": 2.1977833094187718 + }, + { + "step": 1847, + "lr": 0.0001, + "sup_loss": 2.1977147128822105 + }, + { + "step": 1848, + "lr": 0.0001, + "sup_loss": 2.1977626150523397 + }, + { + "step": 1849, + "lr": 0.0001, + "sup_loss": 2.197732497742399 + }, + { + "step": 1850, + "lr": 0.0001, + "sup_loss": 2.197724615259195 + }, + { + "step": 1851, + "lr": 0.0001, + "sup_loss": 2.197803195081535 + }, + { + "step": 1852, + "lr": 0.0001, + "sup_loss": 2.1976744416168987 + }, + { + "step": 1853, + "lr": 0.0001, + "sup_loss": 2.197678474090652 + }, + { + "step": 1854, + "lr": 0.0001, + "sup_loss": 2.197774948022298 + }, + { + "step": 1855, + "lr": 0.0001, + "sup_loss": 2.1977917311376283 + }, + { + "step": 1856, + "lr": 0.0001, + "sup_loss": 2.1976672623941966 + }, + { + "step": 1857, + "lr": 0.0001, + "sup_loss": 2.1977211079114856 + }, + { + "step": 1858, + "lr": 0.0001, + "sup_loss": 2.197717464233259 + }, + { + "step": 1859, + "lr": 0.0001, + "sup_loss": 2.1977055522936926 + }, + { + "step": 1860, + "lr": 0.0001, + "sup_loss": 2.197703174930594 + }, + { + "step": 1861, + "lr": 0.0001, + "sup_loss": 2.1977839744189915 + }, + { + "step": 1862, + "lr": 0.0001, + "sup_loss": 2.1977390837101956 + }, + { + "step": 1863, + "lr": 0.0001, + "sup_loss": 2.1977230959205443 + }, + { + "step": 1864, + "lr": 0.0001, + "sup_loss": 2.197748800705654 + }, + { + "step": 1865, + "lr": 0.0001, + "sup_loss": 2.197741009998905 + }, + { + "step": 1866, + "lr": 0.0001, + "sup_loss": 2.1976708900365205 + }, + { + "step": 1867, + "lr": 0.0001, + "sup_loss": 2.197720162420808 + }, + { + "step": 1868, + "lr": 0.0001, + "sup_loss": 2.1976667383071034 + }, + { + "step": 1869, + "lr": 0.0001, + "sup_loss": 2.1977636342393234 + }, + { + "step": 1870, + "lr": 0.0001, + "sup_loss": 2.1977254284854673 + }, + { + "step": 1871, + "lr": 0.0001, + "sup_loss": 2.197690462907774 + }, + { + "step": 1872, + "lr": 0.0001, + "sup_loss": 2.1976825728305913 + }, + { + "step": 1873, + "lr": 0.0001, + "sup_loss": 2.197743343348523 + }, + { + "step": 1874, + "lr": 0.0001, + "sup_loss": 2.1977477453929994 + }, + { + "step": 1875, + "lr": 0.0001, + "sup_loss": 2.197712837242841 + }, + { + "step": 1876, + "lr": 0.0001, + "sup_loss": 2.1976362850689273 + }, + { + "step": 1877, + "lr": 0.0001, + "sup_loss": 2.1977052713431124 + }, + { + "step": 1878, + "lr": 0.0001, + "sup_loss": 2.1977061033435343 + }, + { + "step": 1879, + "lr": 0.0001, + "sup_loss": 2.1977112869294415 + }, + { + "step": 1880, + "lr": 0.0001, + "sup_loss": 2.1977512652530504 + }, + { + "step": 1881, + "lr": 0.0001, + "sup_loss": 2.1977141457669576 + }, + { + "step": 1882, + "lr": 0.0001, + "sup_loss": 2.1977221923667734 + }, + { + "step": 1883, + "lr": 0.0001, + "sup_loss": 2.1977526630734574 + }, + { + "step": 1884, + "lr": 0.0001, + "sup_loss": 2.197652454367203 + }, + { + "step": 1885, + "lr": 0.0001, + "sup_loss": 2.1977526935117355 + }, + { + "step": 1886, + "lr": 0.0001, + "sup_loss": 2.197667850061234 + }, + { + "step": 1887, + "lr": 0.0001, + "sup_loss": 2.1977240469308814 + }, + { + "step": 1888, + "lr": 0.0001, + "sup_loss": 2.1977200563758386 + }, + { + "step": 1889, + "lr": 0.0001, + "sup_loss": 2.1978030873570766 + }, + { + "step": 1890, + "lr": 0.0001, + "sup_loss": 2.1977205143435006 + }, + { + "step": 1891, + "lr": 0.0001, + "sup_loss": 2.1977511530375002 + }, + { + "step": 1892, + "lr": 0.0001, + "sup_loss": 2.1977547040027985 + }, + { + "step": 1893, + "lr": 0.0001, + "sup_loss": 2.1977109541741484 + }, + { + "step": 1894, + "lr": 0.0001, + "sup_loss": 2.197741166127671 + }, + { + "step": 1895, + "lr": 0.0001, + "sup_loss": 2.1976976519620766 + }, + { + "step": 1896, + "lr": 0.0001, + "sup_loss": 2.1977258923628122 + }, + { + "step": 1897, + "lr": 0.0001, + "sup_loss": 2.1977131135911065 + }, + { + "step": 1898, + "lr": 0.0001, + "sup_loss": 2.197773317611726 + }, + { + "step": 1899, + "lr": 0.0001, + "sup_loss": 2.197774692958826 + }, + { + "step": 1900, + "lr": 0.0001, + "sup_loss": 2.1977514409826653 + }, + { + "step": 1901, + "lr": 0.0001, + "sup_loss": 2.1977699836524014 + }, + { + "step": 1902, + "lr": 0.0001, + "sup_loss": 2.197725337838308 + }, + { + "step": 1903, + "lr": 0.0001, + "sup_loss": 2.1977419573180654 + }, + { + "step": 1904, + "lr": 0.0001, + "sup_loss": 2.197746821658253 + }, + { + "step": 1905, + "lr": 0.0001, + "sup_loss": 2.197747831685947 + }, + { + "step": 1906, + "lr": 0.0001, + "sup_loss": 2.1977084449607163 + }, + { + "step": 1907, + "lr": 0.0001, + "sup_loss": 2.1977551993476103 + }, + { + "step": 1908, + "lr": 0.0001, + "sup_loss": 2.1977174819636582 + }, + { + "step": 1909, + "lr": 0.0001, + "sup_loss": 2.197727483597083 + }, + { + "step": 1910, + "lr": 0.0001, + "sup_loss": 2.1977849005563748 + }, + { + "step": 1911, + "lr": 0.0001, + "sup_loss": 2.197738949314571 + }, + { + "step": 1912, + "lr": 0.0001, + "sup_loss": 2.1977396905881528 + }, + { + "step": 1913, + "lr": 0.0001, + "sup_loss": 2.197747293828087 + }, + { + "step": 1914, + "lr": 0.0001, + "sup_loss": 2.197754997238081 + }, + { + "step": 1915, + "lr": 0.0001, + "sup_loss": 2.197712415586426 + }, + { + "step": 1916, + "lr": 0.0001, + "sup_loss": 2.1977395089071132 + }, + { + "step": 1917, + "lr": 0.0001, + "sup_loss": 2.197712381683751 + }, + { + "step": 1918, + "lr": 0.0001, + "sup_loss": 2.1977162394996554 + }, + { + "step": 1919, + "lr": 0.0001, + "sup_loss": 2.1976949411457647 + }, + { + "step": 1920, + "lr": 0.0001, + "sup_loss": 2.1977241796319658 + }, + { + "step": 1921, + "lr": 0.0001, + "sup_loss": 2.1977167926194774 + }, + { + "step": 1922, + "lr": 0.0001, + "sup_loss": 2.1977252269487573 + }, + { + "step": 1923, + "lr": 0.0001, + "sup_loss": 2.1976673080836737 + }, + { + "step": 1924, + "lr": 0.0001, + "sup_loss": 2.197719190184312 + }, + { + "step": 1925, + "lr": 0.0001, + "sup_loss": 2.197661759624804 + }, + { + "step": 1926, + "lr": 0.0001, + "sup_loss": 2.1976734585479067 + }, + { + "step": 1927, + "lr": 0.0001, + "sup_loss": 2.197724922278584 + }, + { + "step": 1928, + "lr": 0.0001, + "sup_loss": 2.1977341645804893 + }, + { + "step": 1929, + "lr": 0.0001, + "sup_loss": 2.1977327315123767 + }, + { + "step": 1930, + "lr": 0.0001, + "sup_loss": 2.197782567813421 + }, + { + "step": 1931, + "lr": 0.0001, + "sup_loss": 2.197731733285625 + }, + { + "step": 1932, + "lr": 0.0001, + "sup_loss": 2.1978425868895552 + }, + { + "step": 1933, + "lr": 0.0001, + "sup_loss": 2.1977473080009204 + }, + { + "step": 1934, + "lr": 0.0001, + "sup_loss": 2.1977060457549547 + }, + { + "step": 1935, + "lr": 0.0001, + "sup_loss": 2.197752692378886 + }, + { + "step": 1936, + "lr": 0.0001, + "sup_loss": 2.197766867945943 + }, + { + "step": 1937, + "lr": 0.0001, + "sup_loss": 2.1977298403024985 + }, + { + "step": 1938, + "lr": 0.0001, + "sup_loss": 2.1977419496299255 + }, + { + "step": 1939, + "lr": 0.0001, + "sup_loss": 2.1977862485337294 + }, + { + "step": 1940, + "lr": 0.0001, + "sup_loss": 2.1977512022733596 + }, + { + "step": 1941, + "lr": 0.0001, + "sup_loss": 2.1977595490727633 + }, + { + "step": 1942, + "lr": 0.0001, + "sup_loss": 2.1977173761253175 + }, + { + "step": 1943, + "lr": 0.0001, + "sup_loss": 2.197702594561035 + }, + { + "step": 1944, + "lr": 0.0001, + "sup_loss": 2.197758695489324 + }, + { + "step": 1945, + "lr": 0.0001, + "sup_loss": 2.1977710245571145 + }, + { + "step": 1946, + "lr": 0.0001, + "sup_loss": 2.197750231265883 + }, + { + "step": 1947, + "lr": 0.0001, + "sup_loss": 2.1977056985477272 + }, + { + "step": 1948, + "lr": 0.0001, + "sup_loss": 2.19769527444088 + }, + { + "step": 1949, + "lr": 0.0001, + "sup_loss": 2.197682114645768 + }, + { + "step": 1950, + "lr": 0.0001, + "sup_loss": 2.1977698125944256 + }, + { + "step": 1951, + "lr": 0.0001, + "sup_loss": 2.1977363269669024 + }, + { + "step": 1952, + "lr": 0.0001, + "sup_loss": 2.1976967073217843 + }, + { + "step": 1953, + "lr": 0.0001, + "sup_loss": 2.1977190323826425 + }, + { + "step": 1954, + "lr": 0.0001, + "sup_loss": 2.19768406193022 + }, + { + "step": 1955, + "lr": 0.0001, + "sup_loss": 2.1976503001485823 + }, + { + "step": 1956, + "lr": 0.0001, + "sup_loss": 2.1977765999413723 + }, + { + "step": 1957, + "lr": 0.0001, + "sup_loss": 2.1976873312019225 + }, + { + "step": 1958, + "lr": 0.0001, + "sup_loss": 2.1977152888486744 + }, + { + "step": 1959, + "lr": 0.0001, + "sup_loss": 2.1977356999615707 + }, + { + "step": 1960, + "lr": 0.0001, + "sup_loss": 2.19766905719101 + }, + { + "step": 1961, + "lr": 0.0001, + "sup_loss": 2.1977515009106594 + }, + { + "step": 1962, + "lr": 0.0001, + "sup_loss": 2.197673556557085 + }, + { + "step": 1963, + "lr": 0.0001, + "sup_loss": 2.1977319063164744 + }, + { + "step": 1964, + "lr": 0.0001, + "sup_loss": 2.197731441289644 + }, + { + "step": 1965, + "lr": 0.0001, + "sup_loss": 2.1977278739822714 + }, + { + "step": 1966, + "lr": 0.0001, + "sup_loss": 2.197730344636838 + }, + { + "step": 1967, + "lr": 0.0001, + "sup_loss": 2.197738750762469 + }, + { + "step": 1968, + "lr": 0.0001, + "sup_loss": 2.197735300717977 + }, + { + "step": 1969, + "lr": 0.0001, + "sup_loss": 2.197734040369562 + }, + { + "step": 1970, + "lr": 0.0001, + "sup_loss": 2.1977311122029315 + }, + { + "step": 1971, + "lr": 0.0001, + "sup_loss": 2.197680499987357 + }, + { + "step": 1972, + "lr": 0.0001, + "sup_loss": 2.197699501251349 + }, + { + "step": 1973, + "lr": 0.0001, + "sup_loss": 2.197694234492058 + }, + { + "step": 1974, + "lr": 0.0001, + "sup_loss": 2.1977243554286177 + }, + { + "step": 1975, + "lr": 0.0001, + "sup_loss": 2.1976844717937962 + }, + { + "step": 1976, + "lr": 0.0001, + "sup_loss": 2.1977519457163064 + }, + { + "step": 1977, + "lr": 0.0001, + "sup_loss": 2.1977178221255613 + }, + { + "step": 1978, + "lr": 0.0001, + "sup_loss": 2.1977169947314783 + }, + { + "step": 1979, + "lr": 0.0001, + "sup_loss": 2.1977276914537085 + }, + { + "step": 1980, + "lr": 0.0001, + "sup_loss": 2.197755041398956 + }, + { + "step": 1981, + "lr": 0.0001, + "sup_loss": 2.197782369345404 + }, + { + "step": 1982, + "lr": 0.0001, + "sup_loss": 2.1977023965800733 + }, + { + "step": 1983, + "lr": 0.0001, + "sup_loss": 2.197701718407272 + }, + { + "step": 1984, + "lr": 0.0001, + "sup_loss": 2.197693406491907 + }, + { + "step": 1985, + "lr": 0.0001, + "sup_loss": 2.1976942334573684 + }, + { + "step": 1986, + "lr": 0.0001, + "sup_loss": 2.1976912319921937 + }, + { + "step": 1987, + "lr": 0.0001, + "sup_loss": 2.1976961200324228 + }, + { + "step": 1988, + "lr": 0.0001, + "sup_loss": 2.197694890732937 + }, + { + "step": 1989, + "lr": 0.0001, + "sup_loss": 2.197665934085313 + }, + { + "step": 1990, + "lr": 0.0001, + "sup_loss": 2.197714587384218 + }, + { + "step": 1991, + "lr": 0.0001, + "sup_loss": 2.197710547119641 + }, + { + "step": 1992, + "lr": 0.0001, + "sup_loss": 2.197715152836475 + }, + { + "step": 1993, + "lr": 0.0001, + "sup_loss": 2.19773150332003 + }, + { + "step": 1994, + "lr": 0.0001, + "sup_loss": 2.197688210641288 + }, + { + "step": 1995, + "lr": 0.0001, + "sup_loss": 2.1976853187139236 + }, + { + "step": 1996, + "lr": 0.0001, + "sup_loss": 2.1977057006550815 + }, + { + "step": 1997, + "lr": 0.0001, + "sup_loss": 2.197715869266621 + }, + { + "step": 1998, + "lr": 0.0001, + "sup_loss": 2.197689746366521 + }, + { + "step": 1999, + "lr": 0.0001, + "sup_loss": 2.197709753387666 + }, + { + "step": 2000, + "lr": 0.0001, + "sup_loss": 2.1977290804810643 + }, + { + "step": 2001, + "lr": 0.0001, + "sup_loss": 2.1976560305552644 + }, + { + "step": 2002, + "lr": 0.0001, + "sup_loss": 2.197740027830093 + }, + { + "step": 2003, + "lr": 0.0001, + "sup_loss": 2.197647844081279 + }, + { + "step": 2004, + "lr": 0.0001, + "sup_loss": 2.1976864032676424 + }, + { + "step": 2005, + "lr": 0.0001, + "sup_loss": 2.1976976649017272 + }, + { + "step": 2006, + "lr": 0.0001, + "sup_loss": 2.197663112515036 + }, + { + "step": 2007, + "lr": 0.0001, + "sup_loss": 2.1976657994122513 + }, + { + "step": 2008, + "lr": 0.0001, + "sup_loss": 2.1976620128210467 + }, + { + "step": 2009, + "lr": 0.0001, + "sup_loss": 2.1977236047856348 + }, + { + "step": 2010, + "lr": 0.0001, + "sup_loss": 2.1976754668549803 + }, + { + "step": 2011, + "lr": 0.0001, + "sup_loss": 2.1976043747161444 + }, + { + "step": 2012, + "lr": 0.0001, + "sup_loss": 2.1976598384065595 + }, + { + "step": 2013, + "lr": 0.0001, + "sup_loss": 2.197700525691784 + }, + { + "step": 2014, + "lr": 0.0001, + "sup_loss": 2.1977004709135692 + }, + { + "step": 2015, + "lr": 0.0001, + "sup_loss": 2.1977016766083097 + }, + { + "step": 2016, + "lr": 0.0001, + "sup_loss": 2.1976352144623643 + }, + { + "step": 2017, + "lr": 0.0001, + "sup_loss": 2.197708735697786 + }, + { + "step": 2018, + "lr": 0.0001, + "sup_loss": 2.19760527660657 + }, + { + "step": 2019, + "lr": 0.0001, + "sup_loss": 2.1977138295456786 + }, + { + "step": 2020, + "lr": 0.0001, + "sup_loss": 2.197690782316447 + }, + { + "step": 2021, + "lr": 0.0001, + "sup_loss": 2.197722838022602 + }, + { + "step": 2022, + "lr": 0.0001, + "sup_loss": 2.197660425402486 + }, + { + "step": 2023, + "lr": 0.0001, + "sup_loss": 2.1976662884799945 + }, + { + "step": 2024, + "lr": 0.0001, + "sup_loss": 2.1976932306831225 + }, + { + "step": 2025, + "lr": 0.0001, + "sup_loss": 2.197710880578888 + }, + { + "step": 2026, + "lr": 0.0001, + "sup_loss": 2.1976711419229362 + }, + { + "step": 2027, + "lr": 0.0001, + "sup_loss": 2.197775622004773 + }, + { + "step": 2028, + "lr": 0.0001, + "sup_loss": 2.1976708248029264 + }, + { + "step": 2029, + "lr": 0.0001, + "sup_loss": 2.197686993739473 + }, + { + "step": 2030, + "lr": 0.0001, + "sup_loss": 2.1976219240215586 + }, + { + "step": 2031, + "lr": 0.0001, + "sup_loss": 2.19763924987686 + }, + { + "step": 2032, + "lr": 0.0001, + "sup_loss": 2.197723613432191 + }, + { + "step": 2033, + "lr": 0.0001, + "sup_loss": 2.197728728151402 + }, + { + "step": 2034, + "lr": 0.0001, + "sup_loss": 2.1977748736872984 + }, + { + "step": 2035, + "lr": 0.0001, + "sup_loss": 2.197664679098935 + }, + { + "step": 2036, + "lr": 0.0001, + "sup_loss": 2.197674617084811 + }, + { + "step": 2037, + "lr": 0.0001, + "sup_loss": 2.1976742399040754 + }, + { + "step": 2038, + "lr": 0.0001, + "sup_loss": 2.19767457129692 + }, + { + "step": 2039, + "lr": 0.0001, + "sup_loss": 2.197691192115907 + }, + { + "step": 2040, + "lr": 0.0001, + "sup_loss": 2.197667461481712 + }, + { + "step": 2041, + "lr": 0.0001, + "sup_loss": 2.197600912057398 + }, + { + "step": 2042, + "lr": 0.0001, + "sup_loss": 2.1976689411711994 + }, + { + "step": 2043, + "lr": 0.0001, + "sup_loss": 2.1976721298345803 + }, + { + "step": 2044, + "lr": 0.0001, + "sup_loss": 2.1976733279803833 + }, + { + "step": 2045, + "lr": 0.0001, + "sup_loss": 2.197697875906186 + }, + { + "step": 2046, + "lr": 0.0001, + "sup_loss": 2.1977114862644793 + }, + { + "step": 2047, + "lr": 0.0001, + "sup_loss": 2.197648198189154 + }, + { + "step": 2048, + "lr": 0.0001, + "sup_loss": 2.1976849216394028 + }, + { + "step": 2049, + "lr": 0.0001, + "sup_loss": 2.1975446696326393 + }, + { + "step": 2050, + "lr": 0.0001, + "sup_loss": 2.197596970922498 + }, + { + "step": 2051, + "lr": 0.0001, + "sup_loss": 2.197712745070719 + }, + { + "step": 2052, + "lr": 0.0001, + "sup_loss": 2.1976348323915698 + }, + { + "step": 2053, + "lr": 0.0001, + "sup_loss": 2.1975606528691607 + }, + { + "step": 2054, + "lr": 0.0001, + "sup_loss": 2.197665142806699 + }, + { + "step": 2055, + "lr": 0.0001, + "sup_loss": 2.1976273461489857 + }, + { + "step": 2056, + "lr": 0.0001, + "sup_loss": 2.1976322764432377 + }, + { + "step": 2057, + "lr": 0.0001, + "sup_loss": 2.197708984799473 + }, + { + "step": 2058, + "lr": 0.0001, + "sup_loss": 2.197743004078699 + }, + { + "step": 2059, + "lr": 0.0001, + "sup_loss": 2.197694266198048 + }, + { + "step": 2060, + "lr": 0.0001, + "sup_loss": 2.1976438136565966 + }, + { + "step": 2061, + "lr": 0.0001, + "sup_loss": 2.1976888839282958 + }, + { + "step": 2062, + "lr": 0.0001, + "sup_loss": 2.1977012997917353 + }, + { + "step": 2063, + "lr": 0.0001, + "sup_loss": 2.1976928125314275 + }, + { + "step": 2064, + "lr": 0.0001, + "sup_loss": 2.1977173902023424 + }, + { + "step": 2065, + "lr": 0.0001, + "sup_loss": 2.197643842746502 + }, + { + "step": 2066, + "lr": 0.0001, + "sup_loss": 2.1976476789774506 + }, + { + "step": 2067, + "lr": 0.0001, + "sup_loss": 2.1976460233045314 + }, + { + "step": 2068, + "lr": 0.0001, + "sup_loss": 2.1976954494719254 + }, + { + "step": 2069, + "lr": 0.0001, + "sup_loss": 2.197720656342882 + }, + { + "step": 2070, + "lr": 0.0001, + "sup_loss": 2.1976654532958326 + }, + { + "step": 2071, + "lr": 0.0001, + "sup_loss": 2.1976660075771632 + }, + { + "step": 2072, + "lr": 0.0001, + "sup_loss": 2.197689529727646 + }, + { + "step": 2073, + "lr": 0.0001, + "sup_loss": 2.1976812156487204 + }, + { + "step": 2074, + "lr": 0.0001, + "sup_loss": 2.1976893233243335 + }, + { + "step": 2075, + "lr": 0.0001, + "sup_loss": 2.1976060771252195 + }, + { + "step": 2076, + "lr": 0.0001, + "sup_loss": 2.1975985864699568 + }, + { + "step": 2077, + "lr": 0.0001, + "sup_loss": 2.197719809420511 + }, + { + "step": 2078, + "lr": 0.0001, + "sup_loss": 2.197682679708827 + }, + { + "step": 2079, + "lr": 0.0001, + "sup_loss": 2.197585479084461 + }, + { + "step": 2080, + "lr": 0.0001, + "sup_loss": 2.1976797115345756 + }, + { + "step": 2081, + "lr": 0.0001, + "sup_loss": 2.1976706775894415 + }, + { + "step": 2082, + "lr": 0.0001, + "sup_loss": 2.1976508928785923 + }, + { + "step": 2083, + "lr": 0.0001, + "sup_loss": 2.1976523828164662 + }, + { + "step": 2084, + "lr": 0.0001, + "sup_loss": 2.197640558577139 + }, + { + "step": 2085, + "lr": 0.0001, + "sup_loss": 2.197715416849005 + }, + { + "step": 2086, + "lr": 0.0001, + "sup_loss": 2.1976788445295856 + }, + { + "step": 2087, + "lr": 0.0001, + "sup_loss": 2.197728388463349 + }, + { + "step": 2088, + "lr": 0.0001, + "sup_loss": 2.197623309033105 + }, + { + "step": 2089, + "lr": 0.0001, + "sup_loss": 2.197678831909228 + }, + { + "step": 2090, + "lr": 0.0001, + "sup_loss": 2.1976577334305576 + }, + { + "step": 2091, + "lr": 0.0001, + "sup_loss": 2.1976383982514944 + }, + { + "step": 2092, + "lr": 0.0001, + "sup_loss": 2.197664700246263 + }, + { + "step": 2093, + "lr": 0.0001, + "sup_loss": 2.197627033995399 + }, + { + "step": 2094, + "lr": 0.0001, + "sup_loss": 2.1977321488673085 + }, + { + "step": 2095, + "lr": 0.0001, + "sup_loss": 2.1976878566893587 + }, + { + "step": 2096, + "lr": 0.0001, + "sup_loss": 2.1976400680002808 + }, + { + "step": 2097, + "lr": 0.0001, + "sup_loss": 2.1977105052176684 + }, + { + "step": 2098, + "lr": 0.0001, + "sup_loss": 2.1976708785069174 + }, + { + "step": 2099, + "lr": 0.0001, + "sup_loss": 2.1976569345882884 + }, + { + "step": 2100, + "lr": 0.0001, + "sup_loss": 2.197609138369631 + }, + { + "step": 2101, + "lr": 0.0001, + "sup_loss": 2.197651706340291 + }, + { + "step": 2102, + "lr": 0.0001, + "sup_loss": 2.197672745298603 + }, + { + "step": 2103, + "lr": 0.0001, + "sup_loss": 2.1976142777976486 + }, + { + "step": 2104, + "lr": 0.0001, + "sup_loss": 2.1976419433757237 + }, + { + "step": 2105, + "lr": 0.0001, + "sup_loss": 2.1976430903729174 + }, + { + "step": 2106, + "lr": 0.0001, + "sup_loss": 2.1975990648990296 + }, + { + "step": 2107, + "lr": 0.0001, + "sup_loss": 2.197686676318199 + }, + { + "step": 2108, + "lr": 0.0001, + "sup_loss": 2.1976796276292405 + }, + { + "step": 2109, + "lr": 0.0001, + "sup_loss": 2.1977243102134745 + }, + { + "step": 2110, + "lr": 0.0001, + "sup_loss": 2.197646506952401 + }, + { + "step": 2111, + "lr": 0.0001, + "sup_loss": 2.1977035533922917 + }, + { + "step": 2112, + "lr": 0.0001, + "sup_loss": 2.1977242638863794 + }, + { + "step": 2113, + "lr": 0.0001, + "sup_loss": 2.1977501868235825 + }, + { + "step": 2114, + "lr": 0.0001, + "sup_loss": 2.1977721860291854 + }, + { + "step": 2115, + "lr": 0.0001, + "sup_loss": 2.1976501055836497 + }, + { + "step": 2116, + "lr": 0.0001, + "sup_loss": 2.197596477994951 + }, + { + "step": 2117, + "lr": 0.0001, + "sup_loss": 2.1978118536709497 + }, + { + "step": 2118, + "lr": 0.0001, + "sup_loss": 2.197713377180862 + }, + { + "step": 2119, + "lr": 0.0001, + "sup_loss": 2.1976816341229104 + }, + { + "step": 2120, + "lr": 0.0001, + "sup_loss": 2.197612192767874 + }, + { + "step": 2121, + "lr": 0.0001, + "sup_loss": 2.1976450062423885 + }, + { + "step": 2122, + "lr": 0.0001, + "sup_loss": 2.197626894719833 + }, + { + "step": 2123, + "lr": 0.0001, + "sup_loss": 2.19761075391372 + }, + { + "step": 2124, + "lr": 0.0001, + "sup_loss": 2.1977093772080307 + }, + { + "step": 2125, + "lr": 0.0001, + "sup_loss": 2.1977394498739233 + }, + { + "step": 2126, + "lr": 0.0001, + "sup_loss": 2.197688793961908 + }, + { + "step": 2127, + "lr": 0.0001, + "sup_loss": 2.197699451990665 + }, + { + "step": 2128, + "lr": 0.0001, + "sup_loss": 2.197674514192003 + }, + { + "step": 2129, + "lr": 0.0001, + "sup_loss": 2.1977314781332797 + }, + { + "step": 2130, + "lr": 0.0001, + "sup_loss": 2.19767528646467 + }, + { + "step": 2131, + "lr": 0.0001, + "sup_loss": 2.1976520215282984 + }, + { + "step": 2132, + "lr": 0.0001, + "sup_loss": 2.1976594190845575 + }, + { + "step": 2133, + "lr": 0.0001, + "sup_loss": 2.1976596016678998 + }, + { + "step": 2134, + "lr": 0.0001, + "sup_loss": 2.197692680691051 + }, + { + "step": 2135, + "lr": 0.0001, + "sup_loss": 2.197660016745529 + }, + { + "step": 2136, + "lr": 0.0001, + "sup_loss": 2.19763389774783 + }, + { + "step": 2137, + "lr": 0.0001, + "sup_loss": 2.1976483165506564 + }, + { + "step": 2138, + "lr": 0.0001, + "sup_loss": 2.1976369454186404 + }, + { + "step": 2139, + "lr": 0.0001, + "sup_loss": 2.1976299130620633 + }, + { + "step": 2140, + "lr": 0.0001, + "sup_loss": 2.1976369688920254 + }, + { + "step": 2141, + "lr": 0.0001, + "sup_loss": 2.197607857795633 + }, + { + "step": 2142, + "lr": 0.0001, + "sup_loss": 2.197611600839959 + }, + { + "step": 2143, + "lr": 0.0001, + "sup_loss": 2.197686472778659 + }, + { + "step": 2144, + "lr": 0.0001, + "sup_loss": 2.1976631783646687 + }, + { + "step": 2145, + "lr": 0.0001, + "sup_loss": 2.1976641020752448 + }, + { + "step": 2146, + "lr": 0.0001, + "sup_loss": 2.197605405120139 + }, + { + "step": 2147, + "lr": 0.0001, + "sup_loss": 2.1975933733029103 + }, + { + "step": 2148, + "lr": 0.0001, + "sup_loss": 2.197635887567939 + }, + { + "step": 2149, + "lr": 0.0001, + "sup_loss": 2.1976603506483423 + }, + { + "step": 2150, + "lr": 0.0001, + "sup_loss": 2.1975869977871274 + }, + { + "step": 2151, + "lr": 0.0001, + "sup_loss": 2.1975981237364675 + }, + { + "step": 2152, + "lr": 0.0001, + "sup_loss": 2.197553860601202 + }, + { + "step": 2153, + "lr": 0.0001, + "sup_loss": 2.1975420631781266 + }, + { + "step": 2154, + "lr": 0.0001, + "sup_loss": 2.197575862511327 + }, + { + "step": 2155, + "lr": 0.0001, + "sup_loss": 2.19758640551878 + }, + { + "step": 2156, + "lr": 0.0001, + "sup_loss": 2.1975916545282415 + }, + { + "step": 2157, + "lr": 0.0001, + "sup_loss": 2.1975956250394595 + }, + { + "step": 2158, + "lr": 0.0001, + "sup_loss": 2.197589413016662 + }, + { + "step": 2159, + "lr": 0.0001, + "sup_loss": 2.1975382716494885 + }, + { + "step": 2160, + "lr": 0.0001, + "sup_loss": 2.197552491199124 + }, + { + "step": 2161, + "lr": 0.0001, + "sup_loss": 2.1975568934292187 + }, + { + "step": 2162, + "lr": 0.0001, + "sup_loss": 2.1975575851931226 + }, + { + "step": 2163, + "lr": 0.0001, + "sup_loss": 2.1975355646177537 + }, + { + "step": 2164, + "lr": 0.0001, + "sup_loss": 2.1975230686687577 + }, + { + "step": 2165, + "lr": 0.0001, + "sup_loss": 2.1975621500159415 + }, + { + "step": 2166, + "lr": 0.0001, + "sup_loss": 2.197583355592156 + }, + { + "step": 2167, + "lr": 0.0001, + "sup_loss": 2.1975564223279203 + }, + { + "step": 2168, + "lr": 0.0001, + "sup_loss": 2.1975239630472725 + }, + { + "step": 2169, + "lr": 0.0001, + "sup_loss": 2.197544844322906 + }, + { + "step": 2170, + "lr": 0.0001, + "sup_loss": 2.197531012211215 + }, + { + "step": 2171, + "lr": 0.0001, + "sup_loss": 2.1976265158221895 + }, + { + "step": 2172, + "lr": 0.0001, + "sup_loss": 2.1976109614283814 + }, + { + "step": 2173, + "lr": 0.0001, + "sup_loss": 2.197673269018714 + }, + { + "step": 2174, + "lr": 0.0001, + "sup_loss": 2.1975570771478643 + }, + { + "step": 2175, + "lr": 0.0001, + "sup_loss": 2.197587771905514 + }, + { + "step": 2176, + "lr": 0.0001, + "sup_loss": 2.1976020610110893 + }, + { + "step": 2177, + "lr": 0.0001, + "sup_loss": 2.1976300075843147 + }, + { + "step": 2178, + "lr": 0.0001, + "sup_loss": 2.197497860073451 + }, + { + "step": 2179, + "lr": 0.0001, + "sup_loss": 2.1975750652396226 + }, + { + "step": 2180, + "lr": 0.0001, + "sup_loss": 2.197562856484625 + }, + { + "step": 2181, + "lr": 0.0001, + "sup_loss": 2.1976125744661723 + }, + { + "step": 2182, + "lr": 0.0001, + "sup_loss": 2.197628767260988 + }, + { + "step": 2183, + "lr": 0.0001, + "sup_loss": 2.197566154927748 + }, + { + "step": 2184, + "lr": 0.0001, + "sup_loss": 2.197514244401524 + }, + { + "step": 2185, + "lr": 0.0001, + "sup_loss": 2.197537784321454 + }, + { + "step": 2186, + "lr": 0.0001, + "sup_loss": 2.197585597733663 + }, + { + "step": 2187, + "lr": 0.0001, + "sup_loss": 2.197559131761254 + }, + { + "step": 2188, + "lr": 0.0001, + "sup_loss": 2.1975158343324903 + }, + { + "step": 2189, + "lr": 0.0001, + "sup_loss": 2.19760192178478 + }, + { + "step": 2190, + "lr": 0.0001, + "sup_loss": 2.1975992598895053 + }, + { + "step": 2191, + "lr": 0.0001, + "sup_loss": 2.1976270057830587 + }, + { + "step": 2192, + "lr": 0.0001, + "sup_loss": 2.1976018332075484 + }, + { + "step": 2193, + "lr": 0.0001, + "sup_loss": 2.197535628492029 + }, + { + "step": 2194, + "lr": 0.0001, + "sup_loss": 2.1975196263605503 + }, + { + "step": 2195, + "lr": 0.0001, + "sup_loss": 2.197572431249092 + }, + { + "step": 2196, + "lr": 0.0001, + "sup_loss": 2.1976619146482554 + }, + { + "step": 2197, + "lr": 0.0001, + "sup_loss": 2.1975210781493546 + }, + { + "step": 2198, + "lr": 0.0001, + "sup_loss": 2.1975627601747636 + }, + { + "step": 2199, + "lr": 0.0001, + "sup_loss": 2.1975730758055554 + }, + { + "step": 2200, + "lr": 0.0001, + "sup_loss": 2.197604081179638 + }, + { + "step": 2201, + "lr": 0.0001, + "sup_loss": 2.1975195737556 + }, + { + "step": 2202, + "lr": 0.0001, + "sup_loss": 2.1976044189378614 + }, + { + "step": 2203, + "lr": 0.0001, + "sup_loss": 2.197562881160259 + }, + { + "step": 2204, + "lr": 0.0001, + "sup_loss": 2.1975728370669145 + }, + { + "step": 2205, + "lr": 0.0001, + "sup_loss": 2.1975494280720635 + }, + { + "step": 2206, + "lr": 0.0001, + "sup_loss": 2.197550306689913 + }, + { + "step": 2207, + "lr": 0.0001, + "sup_loss": 2.1975356046017125 + }, + { + "step": 2208, + "lr": 0.0001, + "sup_loss": 2.197582004998493 + }, + { + "step": 2209, + "lr": 0.0001, + "sup_loss": 2.1976191158228096 + }, + { + "step": 2210, + "lr": 0.0001, + "sup_loss": 2.1975112736533156 + }, + { + "step": 2211, + "lr": 0.0001, + "sup_loss": 2.1975065565000396 + }, + { + "step": 2212, + "lr": 0.0001, + "sup_loss": 2.197636696912758 + }, + { + "step": 2213, + "lr": 0.0001, + "sup_loss": 2.1976624745756954 + }, + { + "step": 2214, + "lr": 0.0001, + "sup_loss": 2.1975618785225013 + }, + { + "step": 2215, + "lr": 0.0001, + "sup_loss": 2.197481501644292 + }, + { + "step": 2216, + "lr": 0.0001, + "sup_loss": 2.1975623759823986 + }, + { + "step": 2217, + "lr": 0.0001, + "sup_loss": 2.197574357698793 + }, + { + "step": 2218, + "lr": 0.0001, + "sup_loss": 2.1976280065654765 + }, + { + "step": 2219, + "lr": 0.0001, + "sup_loss": 2.1974984466996808 + }, + { + "step": 2220, + "lr": 0.0001, + "sup_loss": 2.1975689238948073 + }, + { + "step": 2221, + "lr": 0.0001, + "sup_loss": 2.1976410509592412 + }, + { + "step": 2222, + "lr": 0.0001, + "sup_loss": 2.197563653394737 + }, + { + "step": 2223, + "lr": 0.0001, + "sup_loss": 2.1974522465393527 + }, + { + "step": 2224, + "lr": 0.0001, + "sup_loss": 2.1975508311201097 + }, + { + "step": 2225, + "lr": 0.0001, + "sup_loss": 2.197471511544881 + }, + { + "step": 2226, + "lr": 0.0001, + "sup_loss": 2.1975867573259515 + }, + { + "step": 2227, + "lr": 0.0001, + "sup_loss": 2.1975788525489977 + }, + { + "step": 2228, + "lr": 0.0001, + "sup_loss": 2.1975799208491735 + }, + { + "step": 2229, + "lr": 0.0001, + "sup_loss": 2.1975556818370237 + }, + { + "step": 2230, + "lr": 0.0001, + "sup_loss": 2.1975536478274775 + }, + { + "step": 2231, + "lr": 0.0001, + "sup_loss": 2.1975829728556975 + }, + { + "step": 2232, + "lr": 0.0001, + "sup_loss": 2.1975485980818306 + }, + { + "step": 2233, + "lr": 0.0001, + "sup_loss": 2.1976126348881837 + }, + { + "step": 2234, + "lr": 0.0001, + "sup_loss": 2.1975942297571707 + }, + { + "step": 2235, + "lr": 0.0001, + "sup_loss": 2.1975800614232965 + }, + { + "step": 2236, + "lr": 0.0001, + "sup_loss": 2.197673693926149 + }, + { + "step": 2237, + "lr": 0.0001, + "sup_loss": 2.197591495257423 + }, + { + "step": 2238, + "lr": 0.0001, + "sup_loss": 2.197645969083851 + }, + { + "step": 2239, + "lr": 0.0001, + "sup_loss": 2.1976214266989116 + }, + { + "step": 2240, + "lr": 0.0001, + "sup_loss": 2.197645741252334 + }, + { + "step": 2241, + "lr": 0.0001, + "sup_loss": 2.197558570652679 + }, + { + "step": 2242, + "lr": 0.0001, + "sup_loss": 2.197613241444215 + }, + { + "step": 2243, + "lr": 0.0001, + "sup_loss": 2.1975883892056998 + }, + { + "step": 2244, + "lr": 0.0001, + "sup_loss": 2.197594080788825 + }, + { + "step": 2245, + "lr": 0.0001, + "sup_loss": 2.197599628961375 + }, + { + "step": 2246, + "lr": 0.0001, + "sup_loss": 2.1976308840514758 + }, + { + "step": 2247, + "lr": 0.0001, + "sup_loss": 2.197594681286262 + }, + { + "step": 2248, + "lr": 0.0001, + "sup_loss": 2.1975507608554685 + }, + { + "step": 2249, + "lr": 0.0001, + "sup_loss": 2.1975763357196114 + }, + { + "step": 2250, + "lr": 0.0001, + "sup_loss": 2.197653708809468 + }, + { + "step": 2251, + "lr": 0.0001, + "sup_loss": 2.1975789133682095 + }, + { + "step": 2252, + "lr": 0.0001, + "sup_loss": 2.197566441415244 + }, + { + "step": 2253, + "lr": 0.0001, + "sup_loss": 2.197496886999567 + }, + { + "step": 2254, + "lr": 0.0001, + "sup_loss": 2.197659349754301 + }, + { + "step": 2255, + "lr": 0.0001, + "sup_loss": 2.197557726911345 + }, + { + "step": 2256, + "lr": 0.0001, + "sup_loss": 2.1975688426918816 + }, + { + "step": 2257, + "lr": 0.0001, + "sup_loss": 2.197601133957335 + }, + { + "step": 2258, + "lr": 0.0001, + "sup_loss": 2.197590887347838 + }, + { + "step": 2259, + "lr": 0.0001, + "sup_loss": 2.1975968763855915 + }, + { + "step": 2260, + "lr": 0.0001, + "sup_loss": 2.197587704638794 + }, + { + "step": 2261, + "lr": 0.0001, + "sup_loss": 2.1975997627460955 + }, + { + "step": 2262, + "lr": 0.0001, + "sup_loss": 2.1976073851713434 + }, + { + "step": 2263, + "lr": 0.0001, + "sup_loss": 2.1975388204869097 + }, + { + "step": 2264, + "lr": 0.0001, + "sup_loss": 2.1975531106188204 + }, + { + "step": 2265, + "lr": 0.0001, + "sup_loss": 2.1976149523471094 + }, + { + "step": 2266, + "lr": 0.0001, + "sup_loss": 2.1975820048066996 + }, + { + "step": 2267, + "lr": 0.0001, + "sup_loss": 2.1975681956960402 + }, + { + "step": 2268, + "lr": 0.0001, + "sup_loss": 2.1975511531251066 + }, + { + "step": 2269, + "lr": 0.0001, + "sup_loss": 2.1976545845864477 + }, + { + "step": 2270, + "lr": 0.0001, + "sup_loss": 2.197573246984752 + }, + { + "step": 2271, + "lr": 0.0001, + "sup_loss": 2.1976242718715433 + }, + { + "step": 2272, + "lr": 0.0001, + "sup_loss": 2.1976021064762103 + }, + { + "step": 2273, + "lr": 0.0001, + "sup_loss": 2.197557131525083 + }, + { + "step": 2274, + "lr": 0.0001, + "sup_loss": 2.197531598496699 + }, + { + "step": 2275, + "lr": 0.0001, + "sup_loss": 2.197515070598994 + }, + { + "step": 2276, + "lr": 0.0001, + "sup_loss": 2.1975640394567364 + }, + { + "step": 2277, + "lr": 0.0001, + "sup_loss": 2.1976122588581783 + }, + { + "step": 2278, + "lr": 0.0001, + "sup_loss": 2.1975600442526586 + }, + { + "step": 2279, + "lr": 0.0001, + "sup_loss": 2.197542932501181 + }, + { + "step": 2280, + "lr": 0.0001, + "sup_loss": 2.197574606135568 + }, + { + "step": 2281, + "lr": 0.0001, + "sup_loss": 2.1975610195430315 + }, + { + "step": 2282, + "lr": 0.0001, + "sup_loss": 2.1976336333017463 + }, + { + "step": 2283, + "lr": 0.0001, + "sup_loss": 2.197576549097433 + }, + { + "step": 2284, + "lr": 0.0001, + "sup_loss": 2.197637760563884 + }, + { + "step": 2285, + "lr": 0.0001, + "sup_loss": 2.197547645955603 + }, + { + "step": 2286, + "lr": 0.0001, + "sup_loss": 2.197567157919039 + }, + { + "step": 2287, + "lr": 0.0001, + "sup_loss": 2.1975805284657173 + }, + { + "step": 2288, + "lr": 0.0001, + "sup_loss": 2.1975378744790945 + }, + { + "step": 2289, + "lr": 0.0001, + "sup_loss": 2.197614694072844 + }, + { + "step": 2290, + "lr": 0.0001, + "sup_loss": 2.197530019231884 + }, + { + "step": 2291, + "lr": 0.0001, + "sup_loss": 2.197601382921572 + }, + { + "step": 2292, + "lr": 0.0001, + "sup_loss": 2.197595109379134 + }, + { + "step": 2293, + "lr": 0.0001, + "sup_loss": 2.197553567411493 + }, + { + "step": 2294, + "lr": 0.0001, + "sup_loss": 2.197655787526325 + }, + { + "step": 2295, + "lr": 0.0001, + "sup_loss": 2.197574156933794 + }, + { + "step": 2296, + "lr": 0.0001, + "sup_loss": 2.1975388933064703 + }, + { + "step": 2297, + "lr": 0.0001, + "sup_loss": 2.197570736742188 + }, + { + "step": 2298, + "lr": 0.0001, + "sup_loss": 2.1975579151112745 + }, + { + "step": 2299, + "lr": 0.0001, + "sup_loss": 2.197644680817581 + }, + { + "step": 2300, + "lr": 0.0001, + "sup_loss": 2.1975139900473977 + }, + { + "step": 2301, + "lr": 0.0001, + "sup_loss": 2.1975590344148213 + }, + { + "step": 2302, + "lr": 0.0001, + "sup_loss": 2.197553975085885 + }, + { + "step": 2303, + "lr": 0.0001, + "sup_loss": 2.197558211214945 + }, + { + "step": 2304, + "lr": 0.0001, + "sup_loss": 2.1975299780558557 + }, + { + "step": 2305, + "lr": 0.0001, + "sup_loss": 2.1975334860533975 + }, + { + "step": 2306, + "lr": 0.0001, + "sup_loss": 2.1976035582567444 + }, + { + "step": 2307, + "lr": 0.0001, + "sup_loss": 2.197541958749685 + }, + { + "step": 2308, + "lr": 0.0001, + "sup_loss": 2.197536705315575 + }, + { + "step": 2309, + "lr": 0.0001, + "sup_loss": 2.197542860840299 + }, + { + "step": 2310, + "lr": 0.0001, + "sup_loss": 2.1976331841763788 + }, + { + "step": 2311, + "lr": 0.0001, + "sup_loss": 2.197591030987706 + }, + { + "step": 2312, + "lr": 0.0001, + "sup_loss": 2.1975050227430764 + }, + { + "step": 2313, + "lr": 0.0001, + "sup_loss": 2.197580915680084 + }, + { + "step": 2314, + "lr": 0.0001, + "sup_loss": 2.197610228349318 + }, + { + "step": 2315, + "lr": 0.0001, + "sup_loss": 2.197592888295101 + }, + { + "step": 2316, + "lr": 0.0001, + "sup_loss": 2.197629606308375 + }, + { + "step": 2317, + "lr": 0.0001, + "sup_loss": 2.197587630859258 + }, + { + "step": 2318, + "lr": 0.0001, + "sup_loss": 2.1975748519928224 + }, + { + "step": 2319, + "lr": 0.0001, + "sup_loss": 2.1976453848201247 + }, + { + "step": 2320, + "lr": 0.0001, + "sup_loss": 2.1975894704962498 + }, + { + "step": 2321, + "lr": 0.0001, + "sup_loss": 2.197613873028639 + }, + { + "step": 2322, + "lr": 0.0001, + "sup_loss": 2.1975903076066943 + }, + { + "step": 2323, + "lr": 0.0001, + "sup_loss": 2.197575610074773 + }, + { + "step": 2324, + "lr": 0.0001, + "sup_loss": 2.197642508356727 + }, + { + "step": 2325, + "lr": 0.0001, + "sup_loss": 2.197575466891006 + }, + { + "step": 2326, + "lr": 0.0001, + "sup_loss": 2.197659715851036 + }, + { + "step": 2327, + "lr": 0.0001, + "sup_loss": 2.197577369748645 + }, + { + "step": 2328, + "lr": 0.0001, + "sup_loss": 2.197563281241573 + }, + { + "step": 2329, + "lr": 0.0001, + "sup_loss": 2.197567585867462 + }, + { + "step": 2330, + "lr": 0.0001, + "sup_loss": 2.197580561935516 + }, + { + "step": 2331, + "lr": 0.0001, + "sup_loss": 2.197570903666919 + }, + { + "step": 2332, + "lr": 0.0001, + "sup_loss": 2.1975766565600523 + }, + { + "step": 2333, + "lr": 0.0001, + "sup_loss": 2.197575094304279 + }, + { + "step": 2334, + "lr": 0.0001, + "sup_loss": 2.197599393880783 + }, + { + "step": 2335, + "lr": 0.0001, + "sup_loss": 2.197596056789526 + }, + { + "step": 2336, + "lr": 0.0001, + "sup_loss": 2.197586984645291 + }, + { + "step": 2337, + "lr": 0.0001, + "sup_loss": 2.1976208247626925 + }, + { + "step": 2338, + "lr": 0.0001, + "sup_loss": 2.197635967445235 + }, + { + "step": 2339, + "lr": 0.0001, + "sup_loss": 2.197534065384118 + }, + { + "step": 2340, + "lr": 0.0001, + "sup_loss": 2.197638472422267 + }, + { + "step": 2341, + "lr": 0.0001, + "sup_loss": 2.197569931706048 + }, + { + "step": 2342, + "lr": 0.0001, + "sup_loss": 2.197578040206865 + }, + { + "step": 2343, + "lr": 0.0001, + "sup_loss": 2.1975605626173005 + }, + { + "step": 2344, + "lr": 0.0001, + "sup_loss": 2.1975843964280184 + }, + { + "step": 2345, + "lr": 0.0001, + "sup_loss": 2.1975276480301655 + }, + { + "step": 2346, + "lr": 0.0001, + "sup_loss": 2.197576621078619 + }, + { + "step": 2347, + "lr": 0.0001, + "sup_loss": 2.197542430553265 + }, + { + "step": 2348, + "lr": 0.0001, + "sup_loss": 2.197597706103325 + }, + { + "step": 2349, + "lr": 0.0001, + "sup_loss": 2.1975428626950735 + }, + { + "step": 2350, + "lr": 0.0001, + "sup_loss": 2.197622323737495 + }, + { + "step": 2351, + "lr": 0.0001, + "sup_loss": 2.197530100814644 + }, + { + "step": 2352, + "lr": 0.0001, + "sup_loss": 2.197649232892382 + }, + { + "step": 2353, + "lr": 0.0001, + "sup_loss": 2.197543591117077 + }, + { + "step": 2354, + "lr": 0.0001, + "sup_loss": 2.1975578253586465 + }, + { + "step": 2355, + "lr": 0.0001, + "sup_loss": 2.1975163473812835 + }, + { + "step": 2356, + "lr": 0.0001, + "sup_loss": 2.197584569199289 + }, + { + "step": 2357, + "lr": 0.0001, + "sup_loss": 2.1975564545111688 + }, + { + "step": 2358, + "lr": 0.0001, + "sup_loss": 2.197538961960719 + }, + { + "step": 2359, + "lr": 0.0001, + "sup_loss": 2.1975734708300827 + }, + { + "step": 2360, + "lr": 0.0001, + "sup_loss": 2.197565773643539 + }, + { + "step": 2361, + "lr": 0.0001, + "sup_loss": 2.1975103367953976 + }, + { + "step": 2362, + "lr": 0.0001, + "sup_loss": 2.1975703778461155 + }, + { + "step": 2363, + "lr": 0.0001, + "sup_loss": 2.197499418370939 + }, + { + "step": 2364, + "lr": 0.0001, + "sup_loss": 2.1975446196595874 + }, + { + "step": 2365, + "lr": 0.0001, + "sup_loss": 2.1975835277252913 + }, + { + "step": 2366, + "lr": 0.0001, + "sup_loss": 2.197505835188244 + }, + { + "step": 2367, + "lr": 0.0001, + "sup_loss": 2.1975704835219654 + }, + { + "step": 2368, + "lr": 0.0001, + "sup_loss": 2.197486440168504 + }, + { + "step": 2369, + "lr": 0.0001, + "sup_loss": 2.1975865058462345 + }, + { + "step": 2370, + "lr": 0.0001, + "sup_loss": 2.1975270109496305 + }, + { + "step": 2371, + "lr": 0.0001, + "sup_loss": 2.197542013859769 + }, + { + "step": 2372, + "lr": 0.0001, + "sup_loss": 2.1975746943476993 + }, + { + "step": 2373, + "lr": 0.0001, + "sup_loss": 2.1975542744595646 + }, + { + "step": 2374, + "lr": 0.0001, + "sup_loss": 2.197526823416141 + }, + { + "step": 2375, + "lr": 0.0001, + "sup_loss": 2.1975103589008538 + }, + { + "step": 2376, + "lr": 0.0001, + "sup_loss": 2.1975349080268156 + }, + { + "step": 2377, + "lr": 0.0001, + "sup_loss": 2.1976083054195437 + }, + { + "step": 2378, + "lr": 0.0001, + "sup_loss": 2.197573593292026 + }, + { + "step": 2379, + "lr": 0.0001, + "sup_loss": 2.197583497362058 + }, + { + "step": 2380, + "lr": 0.0001, + "sup_loss": 2.1975786293176602 + }, + { + "step": 2381, + "lr": 0.0001, + "sup_loss": 2.1975773059831267 + }, + { + "step": 2382, + "lr": 0.0001, + "sup_loss": 2.197604446768995 + }, + { + "step": 2383, + "lr": 0.0001, + "sup_loss": 2.1975763545515106 + }, + { + "step": 2384, + "lr": 0.0001, + "sup_loss": 2.197611489899633 + }, + { + "step": 2385, + "lr": 0.0001, + "sup_loss": 2.197507811863051 + }, + { + "step": 2386, + "lr": 0.0001, + "sup_loss": 2.197545119698319 + }, + { + "step": 2387, + "lr": 0.0001, + "sup_loss": 2.197580199167834 + }, + { + "step": 2388, + "lr": 0.0001, + "sup_loss": 2.197629460885037 + }, + { + "step": 2389, + "lr": 0.0001, + "sup_loss": 2.1975449152131104 + }, + { + "step": 2390, + "lr": 0.0001, + "sup_loss": 2.19751582889043 + }, + { + "step": 2391, + "lr": 0.0001, + "sup_loss": 2.1975922438889457 + }, + { + "step": 2392, + "lr": 0.0001, + "sup_loss": 2.197624403127133 + }, + { + "step": 2393, + "lr": 0.0001, + "sup_loss": 2.1975484109951053 + }, + { + "step": 2394, + "lr": 0.0001, + "sup_loss": 2.1975124613251236 + }, + { + "step": 2395, + "lr": 0.0001, + "sup_loss": 2.197583234830682 + }, + { + "step": 2396, + "lr": 0.0001, + "sup_loss": 2.197536101428984 + }, + { + "step": 2397, + "lr": 0.0001, + "sup_loss": 2.197610350454119 + }, + { + "step": 2398, + "lr": 0.0001, + "sup_loss": 2.197556867118656 + }, + { + "step": 2399, + "lr": 0.0001, + "sup_loss": 2.197537937051806 + }, + { + "step": 2400, + "lr": 0.0001, + "sup_loss": 2.1975351998400603 + }, + { + "step": 2401, + "lr": 0.0001, + "sup_loss": 2.1976270899793295 + }, + { + "step": 2402, + "lr": 0.0001, + "sup_loss": 2.1975006090062914 + }, + { + "step": 2403, + "lr": 0.0001, + "sup_loss": 2.1975806000515794 + }, + { + "step": 2404, + "lr": 0.0001, + "sup_loss": 2.197560941780369 + }, + { + "step": 2405, + "lr": 0.0001, + "sup_loss": 2.1975038746916287 + }, + { + "step": 2406, + "lr": 0.0001, + "sup_loss": 2.197566038453268 + }, + { + "step": 2407, + "lr": 0.0001, + "sup_loss": 2.1975327282913044 + }, + { + "step": 2408, + "lr": 0.0001, + "sup_loss": 2.197553779621673 + }, + { + "step": 2409, + "lr": 0.0001, + "sup_loss": 2.1975282164729997 + }, + { + "step": 2410, + "lr": 0.0001, + "sup_loss": 2.1975889901243693 + }, + { + "step": 2411, + "lr": 0.0001, + "sup_loss": 2.1974966664763187 + }, + { + "step": 2412, + "lr": 0.0001, + "sup_loss": 2.1975260203955527 + }, + { + "step": 2413, + "lr": 0.0001, + "sup_loss": 2.19757576218314 + }, + { + "step": 2414, + "lr": 0.0001, + "sup_loss": 2.1976175776281934 + }, + { + "step": 2415, + "lr": 0.0001, + "sup_loss": 2.197539402993306 + }, + { + "step": 2416, + "lr": 0.0001, + "sup_loss": 2.197508356363808 + }, + { + "step": 2417, + "lr": 0.0001, + "sup_loss": 2.197528519990277 + }, + { + "step": 2418, + "lr": 0.0001, + "sup_loss": 2.1975734715159554 + }, + { + "step": 2419, + "lr": 0.0001, + "sup_loss": 2.1975302920778335 + }, + { + "step": 2420, + "lr": 0.0001, + "sup_loss": 2.1975969560312407 + }, + { + "step": 2421, + "lr": 0.0001, + "sup_loss": 2.1975356635166454 + }, + { + "step": 2422, + "lr": 0.0001, + "sup_loss": 2.1975646836413123 + }, + { + "step": 2423, + "lr": 0.0001, + "sup_loss": 2.197544890832968 + }, + { + "step": 2424, + "lr": 0.0001, + "sup_loss": 2.1975788499449553 + }, + { + "step": 2425, + "lr": 0.0001, + "sup_loss": 2.1975466244122766 + }, + { + "step": 2426, + "lr": 0.0001, + "sup_loss": 2.1975424590582966 + }, + { + "step": 2427, + "lr": 0.0001, + "sup_loss": 2.1975360903818357 + }, + { + "step": 2428, + "lr": 0.0001, + "sup_loss": 2.1975112665970844 + }, + { + "step": 2429, + "lr": 0.0001, + "sup_loss": 2.1975892547110076 + }, + { + "step": 2430, + "lr": 0.0001, + "sup_loss": 2.1975722366148593 + }, + { + "step": 2431, + "lr": 0.0001, + "sup_loss": 2.1974876516436854 + }, + { + "step": 2432, + "lr": 0.0001, + "sup_loss": 2.1975015983072064 + }, + { + "step": 2433, + "lr": 0.0001, + "sup_loss": 2.1975540511497798 + }, + { + "step": 2434, + "lr": 0.0001, + "sup_loss": 2.1974905594416216 + }, + { + "step": 2435, + "lr": 0.0001, + "sup_loss": 2.1974621577432454 + }, + { + "step": 2436, + "lr": 0.0001, + "sup_loss": 2.1975257393524457 + }, + { + "step": 2437, + "lr": 0.0001, + "sup_loss": 2.197564265039544 + }, + { + "step": 2438, + "lr": 0.0001, + "sup_loss": 2.197483505311565 + }, + { + "step": 2439, + "lr": 0.0001, + "sup_loss": 2.197518837995884 + }, + { + "step": 2440, + "lr": 0.0001, + "sup_loss": 2.197486653021616 + }, + { + "step": 2441, + "lr": 0.0001, + "sup_loss": 2.1975774919276967 + }, + { + "step": 2442, + "lr": 0.0001, + "sup_loss": 2.1975150152209477 + }, + { + "step": 2443, + "lr": 0.0001, + "sup_loss": 2.1975717229167047 + }, + { + "step": 2444, + "lr": 0.0001, + "sup_loss": 2.1975018880137984 + }, + { + "step": 2445, + "lr": 0.0001, + "sup_loss": 2.1975300944045095 + }, + { + "step": 2446, + "lr": 0.0001, + "sup_loss": 2.197544059050391 + }, + { + "step": 2447, + "lr": 0.0001, + "sup_loss": 2.1975127802926084 + }, + { + "step": 2448, + "lr": 0.0001, + "sup_loss": 2.1975689982804116 + }, + { + "step": 2449, + "lr": 0.0001, + "sup_loss": 2.1975748115876357 + }, + { + "step": 2450, + "lr": 0.0001, + "sup_loss": 2.197473132255474 + }, + { + "step": 2451, + "lr": 0.0001, + "sup_loss": 2.1975429702749123 + }, + { + "step": 2452, + "lr": 0.0001, + "sup_loss": 2.1975424407602584 + }, + { + "step": 2453, + "lr": 0.0001, + "sup_loss": 2.197497657537442 + }, + { + "step": 2454, + "lr": 0.0001, + "sup_loss": 2.1975644181804315 + }, + { + "step": 2455, + "lr": 0.0001, + "sup_loss": 2.1975720624547606 + }, + { + "step": 2456, + "lr": 0.0001, + "sup_loss": 2.197523693677037 + }, + { + "step": 2457, + "lr": 0.0001, + "sup_loss": 2.197528345301415 + }, + { + "step": 2458, + "lr": 0.0001, + "sup_loss": 2.1975636939246095 + }, + { + "step": 2459, + "lr": 0.0001, + "sup_loss": 2.197537564503141 + }, + { + "step": 2460, + "lr": 0.0001, + "sup_loss": 2.1975206239510436 + }, + { + "step": 2461, + "lr": 0.0001, + "sup_loss": 2.1975053437277046 + }, + { + "step": 2462, + "lr": 0.0001, + "sup_loss": 2.1975429246774487 + }, + { + "step": 2463, + "lr": 0.0001, + "sup_loss": 2.1975075938323148 + }, + { + "step": 2464, + "lr": 0.0001, + "sup_loss": 2.197544021665414 + }, + { + "step": 2465, + "lr": 0.0001, + "sup_loss": 2.1975531136936577 + }, + { + "step": 2466, + "lr": 0.0001, + "sup_loss": 2.197546597884208 + }, + { + "step": 2467, + "lr": 0.0001, + "sup_loss": 2.1975323916917167 + }, + { + "step": 2468, + "lr": 0.0001, + "sup_loss": 2.1975594622172103 + }, + { + "step": 2469, + "lr": 0.0001, + "sup_loss": 2.197566403826617 + }, + { + "step": 2470, + "lr": 0.0001, + "sup_loss": 2.19750096182324 + }, + { + "step": 2471, + "lr": 0.0001, + "sup_loss": 2.197548995286655 + }, + { + "step": 2472, + "lr": 0.0001, + "sup_loss": 2.197521178193031 + }, + { + "step": 2473, + "lr": 0.0001, + "sup_loss": 2.197574126718845 + }, + { + "step": 2474, + "lr": 0.0001, + "sup_loss": 2.1975106428150495 + }, + { + "step": 2475, + "lr": 0.0001, + "sup_loss": 2.197523312463766 + }, + { + "step": 2476, + "lr": 0.0001, + "sup_loss": 2.197519926325095 + }, + { + "step": 2477, + "lr": 0.0001, + "sup_loss": 2.1975673365600383 + }, + { + "step": 2478, + "lr": 0.0001, + "sup_loss": 2.1975107475989244 + }, + { + "step": 2479, + "lr": 0.0001, + "sup_loss": 2.1975612172930745 + }, + { + "step": 2480, + "lr": 0.0001, + "sup_loss": 2.1975342909526336 + }, + { + "step": 2481, + "lr": 0.0001, + "sup_loss": 2.1975237214308962 + }, + { + "step": 2482, + "lr": 0.0001, + "sup_loss": 2.1975338948401535 + }, + { + "step": 2483, + "lr": 0.0001, + "sup_loss": 2.197532729852547 + }, + { + "step": 2484, + "lr": 0.0001, + "sup_loss": 2.197491873117049 + }, + { + "step": 2485, + "lr": 0.0001, + "sup_loss": 2.197499267432905 + }, + { + "step": 2486, + "lr": 0.0001, + "sup_loss": 2.197554379894917 + }, + { + "step": 2487, + "lr": 0.0001, + "sup_loss": 2.1975333654130527 + }, + { + "step": 2488, + "lr": 0.0001, + "sup_loss": 2.197513021255194 + }, + { + "step": 2489, + "lr": 0.0001, + "sup_loss": 2.197503371366123 + }, + { + "step": 2490, + "lr": 0.0001, + "sup_loss": 2.19750877240022 + }, + { + "step": 2491, + "lr": 0.0001, + "sup_loss": 2.1975104311047184 + }, + { + "step": 2492, + "lr": 0.0001, + "sup_loss": 2.197571394095612 + }, + { + "step": 2493, + "lr": 0.0001, + "sup_loss": 2.1975347617059082 + }, + { + "step": 2494, + "lr": 0.0001, + "sup_loss": 2.1975287855124437 + }, + { + "step": 2495, + "lr": 0.0001, + "sup_loss": 2.197496169139752 + }, + { + "step": 2496, + "lr": 0.0001, + "sup_loss": 2.197459179196982 + }, + { + "step": 2497, + "lr": 0.0001, + "sup_loss": 2.197552475065693 + }, + { + "step": 2498, + "lr": 0.0001, + "sup_loss": 2.1975587883861634 + }, + { + "step": 2499, + "lr": 0.0001, + "sup_loss": 2.1975209772671866 + }, + { + "step": 2500, + "lr": 0.0001, + "sup_loss": 2.1975427352770134 + }, + { + "step": 2501, + "lr": 0.0001, + "sup_loss": 2.1975241812862967 + }, + { + "step": 2502, + "lr": 0.0001, + "sup_loss": 2.197481909672824 + }, + { + "step": 2503, + "lr": 0.0001, + "sup_loss": 2.197481925062849 + }, + { + "step": 2504, + "lr": 0.0001, + "sup_loss": 2.1974848279400954 + }, + { + "step": 2505, + "lr": 0.0001, + "sup_loss": 2.197473604518709 + }, + { + "step": 2506, + "lr": 0.0001, + "sup_loss": 2.197509670324403 + }, + { + "step": 2507, + "lr": 0.0001, + "sup_loss": 2.1975359562183625 + }, + { + "step": 2508, + "lr": 0.0001, + "sup_loss": 2.1974973389336423 + }, + { + "step": 2509, + "lr": 0.0001, + "sup_loss": 2.1975576764562925 + }, + { + "step": 2510, + "lr": 0.0001, + "sup_loss": 2.1975233886965158 + }, + { + "step": 2511, + "lr": 0.0001, + "sup_loss": 2.1975204915216136 + }, + { + "step": 2512, + "lr": 0.0001, + "sup_loss": 2.1975287923989093 + }, + { + "step": 2513, + "lr": 0.0001, + "sup_loss": 2.1974678145116586 + }, + { + "step": 2514, + "lr": 0.0001, + "sup_loss": 2.197497273296934 + }, + { + "step": 2515, + "lr": 0.0001, + "sup_loss": 2.1975047851388143 + }, + { + "step": 2516, + "lr": 0.0001, + "sup_loss": 2.197537229929383 + }, + { + "step": 2517, + "lr": 0.0001, + "sup_loss": 2.1975386065536915 + }, + { + "step": 2518, + "lr": 0.0001, + "sup_loss": 2.19741679710448 + }, + { + "step": 2519, + "lr": 0.0001, + "sup_loss": 2.197478112777531 + }, + { + "step": 2520, + "lr": 0.0001, + "sup_loss": 2.19747045566285 + }, + { + "step": 2521, + "lr": 0.0001, + "sup_loss": 2.197496423921722 + }, + { + "step": 2522, + "lr": 0.0001, + "sup_loss": 2.197437497308753 + }, + { + "step": 2523, + "lr": 0.0001, + "sup_loss": 2.1974912986684934 + }, + { + "step": 2524, + "lr": 0.0001, + "sup_loss": 2.1974395814420253 + }, + { + "step": 2525, + "lr": 0.0001, + "sup_loss": 2.1975447116486437 + }, + { + "step": 2526, + "lr": 0.0001, + "sup_loss": 2.1974299451289245 + }, + { + "step": 2527, + "lr": 0.0001, + "sup_loss": 2.197452642664947 + }, + { + "step": 2528, + "lr": 0.0001, + "sup_loss": 2.197501518891553 + }, + { + "step": 2529, + "lr": 0.0001, + "sup_loss": 2.197473290615757 + }, + { + "step": 2530, + "lr": 0.0001, + "sup_loss": 2.197485621622135 + }, + { + "step": 2531, + "lr": 0.0001, + "sup_loss": 2.1974676945854 + }, + { + "step": 2532, + "lr": 0.0001, + "sup_loss": 2.1974394636015298 + }, + { + "step": 2533, + "lr": 0.0001, + "sup_loss": 2.197591802584759 + }, + { + "step": 2534, + "lr": 0.0001, + "sup_loss": 2.197467800633518 + }, + { + "step": 2535, + "lr": 0.0001, + "sup_loss": 2.197443165521821 + }, + { + "step": 2536, + "lr": 0.0001, + "sup_loss": 2.197486401535804 + }, + { + "step": 2537, + "lr": 0.0001, + "sup_loss": 2.197522796999085 + }, + { + "step": 2538, + "lr": 0.0001, + "sup_loss": 2.1974232704762455 + }, + { + "step": 2539, + "lr": 0.0001, + "sup_loss": 2.1974932168459462 + }, + { + "step": 2540, + "lr": 0.0001, + "sup_loss": 2.1974875095605504 + }, + { + "step": 2541, + "lr": 0.0001, + "sup_loss": 2.1975138632419755 + }, + { + "step": 2542, + "lr": 0.0001, + "sup_loss": 2.1974914347419996 + }, + { + "step": 2543, + "lr": 0.0001, + "sup_loss": 2.197443029558839 + }, + { + "step": 2544, + "lr": 0.0001, + "sup_loss": 2.1974794063127003 + }, + { + "step": 2545, + "lr": 0.0001, + "sup_loss": 2.1974762953573874 + }, + { + "step": 2546, + "lr": 0.0001, + "sup_loss": 2.1974753051273925 + }, + { + "step": 2547, + "lr": 0.0001, + "sup_loss": 2.197543849820808 + }, + { + "step": 2548, + "lr": 0.0001, + "sup_loss": 2.197489944821343 + }, + { + "step": 2549, + "lr": 0.0001, + "sup_loss": 2.1974984436162064 + }, + { + "step": 2550, + "lr": 0.0001, + "sup_loss": 2.197490965545443 + }, + { + "step": 2551, + "lr": 0.0001, + "sup_loss": 2.1975152824224535 + }, + { + "step": 2552, + "lr": 0.0001, + "sup_loss": 2.1974160881387785 + }, + { + "step": 2553, + "lr": 0.0001, + "sup_loss": 2.1975430211798157 + }, + { + "step": 2554, + "lr": 0.0001, + "sup_loss": 2.1974995423451356 + }, + { + "step": 2555, + "lr": 0.0001, + "sup_loss": 2.1975106703072305 + }, + { + "step": 2556, + "lr": 0.0001, + "sup_loss": 2.1974421806698476 + }, + { + "step": 2557, + "lr": 0.0001, + "sup_loss": 2.1974404613755274 + }, + { + "step": 2558, + "lr": 0.0001, + "sup_loss": 2.197501485129779 + }, + { + "step": 2559, + "lr": 0.0001, + "sup_loss": 2.197441449273815 + }, + { + "step": 2560, + "lr": 0.0001, + "sup_loss": 2.197457405164457 + }, + { + "step": 2561, + "lr": 0.0001, + "sup_loss": 2.197467125766547 + }, + { + "step": 2562, + "lr": 0.0001, + "sup_loss": 2.197493719575001 + }, + { + "step": 2563, + "lr": 0.0001, + "sup_loss": 2.197469676692881 + }, + { + "step": 2564, + "lr": 0.0001, + "sup_loss": 2.19750250632202 + }, + { + "step": 2565, + "lr": 0.0001, + "sup_loss": 2.1974412013302915 + }, + { + "step": 2566, + "lr": 0.0001, + "sup_loss": 2.1974819943444626 + }, + { + "step": 2567, + "lr": 0.0001, + "sup_loss": 2.1975471474309356 + }, + { + "step": 2568, + "lr": 0.0001, + "sup_loss": 2.1974734969502543 + }, + { + "step": 2569, + "lr": 0.0001, + "sup_loss": 2.197484818301627 + }, + { + "step": 2570, + "lr": 0.0001, + "sup_loss": 2.197488278796533 + }, + { + "step": 2571, + "lr": 0.0001, + "sup_loss": 2.1974646723216695 + }, + { + "step": 2572, + "lr": 0.0001, + "sup_loss": 2.1975124465750966 + }, + { + "step": 2573, + "lr": 0.0001, + "sup_loss": 2.1975118180316247 + }, + { + "step": 2574, + "lr": 0.0001, + "sup_loss": 2.1974531173402934 + }, + { + "step": 2575, + "lr": 0.0001, + "sup_loss": 2.1974975490545514 + }, + { + "step": 2576, + "lr": 0.0001, + "sup_loss": 2.197464042382421 + }, + { + "step": 2577, + "lr": 0.0001, + "sup_loss": 2.197516358125558 + }, + { + "step": 2578, + "lr": 0.0001, + "sup_loss": 2.1974885611821793 + }, + { + "step": 2579, + "lr": 0.0001, + "sup_loss": 2.197535628024789 + }, + { + "step": 2580, + "lr": 0.0001, + "sup_loss": 2.1974626036044724 + }, + { + "step": 2581, + "lr": 0.0001, + "sup_loss": 2.197469914728846 + }, + { + "step": 2582, + "lr": 0.0001, + "sup_loss": 2.1974774426068886 + }, + { + "step": 2583, + "lr": 0.0001, + "sup_loss": 2.197496156638196 + }, + { + "step": 2584, + "lr": 0.0001, + "sup_loss": 2.1974381267735303 + }, + { + "step": 2585, + "lr": 0.0001, + "sup_loss": 2.197471496185651 + }, + { + "step": 2586, + "lr": 0.0001, + "sup_loss": 2.1975202817639032 + }, + { + "step": 2587, + "lr": 0.0001, + "sup_loss": 2.197435734125084 + }, + { + "step": 2588, + "lr": 0.0001, + "sup_loss": 2.197515791260637 + }, + { + "step": 2589, + "lr": 0.0001, + "sup_loss": 2.197519994379328 + }, + { + "step": 2590, + "lr": 0.0001, + "sup_loss": 2.1975133677530563 + }, + { + "step": 2591, + "lr": 0.0001, + "sup_loss": 2.1974717599108953 + }, + { + "step": 2592, + "lr": 0.0001, + "sup_loss": 2.1974719833287146 + }, + { + "step": 2593, + "lr": 0.0001, + "sup_loss": 2.1974834540084243 + }, + { + "step": 2594, + "lr": 0.0001, + "sup_loss": 2.1974366613468557 + }, + { + "step": 2595, + "lr": 0.0001, + "sup_loss": 2.1975130056201344 + }, + { + "step": 2596, + "lr": 0.0001, + "sup_loss": 2.197530970103572 + }, + { + "step": 2597, + "lr": 0.0001, + "sup_loss": 2.1975041709437675 + }, + { + "step": 2598, + "lr": 0.0001, + "sup_loss": 2.1974958314443067 + }, + { + "step": 2599, + "lr": 0.0001, + "sup_loss": 2.19755719998386 + }, + { + "step": 2600, + "lr": 0.0001, + "sup_loss": 2.197577436550925 + }, + { + "step": 2601, + "lr": 0.0001, + "sup_loss": 2.1974702972672255 + }, + { + "step": 2602, + "lr": 0.0001, + "sup_loss": 2.1974598615063643 + }, + { + "step": 2603, + "lr": 0.0001, + "sup_loss": 2.1974514385182675 + }, + { + "step": 2604, + "lr": 0.0001, + "sup_loss": 2.19754021324561 + }, + { + "step": 2605, + "lr": 0.0001, + "sup_loss": 2.1975001202147353 + }, + { + "step": 2606, + "lr": 0.0001, + "sup_loss": 2.19749429976224 + }, + { + "step": 2607, + "lr": 0.0001, + "sup_loss": 2.1974636871682214 + }, + { + "step": 2608, + "lr": 0.0001, + "sup_loss": 2.1974562169223124 + }, + { + "step": 2609, + "lr": 0.0001, + "sup_loss": 2.197463869410419 + }, + { + "step": 2610, + "lr": 0.0001, + "sup_loss": 2.1974542361260125 + }, + { + "step": 2611, + "lr": 0.0001, + "sup_loss": 2.1974188828817245 + }, + { + "step": 2612, + "lr": 0.0001, + "sup_loss": 2.197478431900216 + }, + { + "step": 2613, + "lr": 0.0001, + "sup_loss": 2.1975245501389673 + }, + { + "step": 2614, + "lr": 0.0001, + "sup_loss": 2.1974859070533492 + }, + { + "step": 2615, + "lr": 0.0001, + "sup_loss": 2.1975590057727876 + }, + { + "step": 2616, + "lr": 0.0001, + "sup_loss": 2.197536936459285 + }, + { + "step": 2617, + "lr": 0.0001, + "sup_loss": 2.1974502892574277 + }, + { + "step": 2618, + "lr": 0.0001, + "sup_loss": 2.197479160149059 + }, + { + "step": 2619, + "lr": 0.0001, + "sup_loss": 2.197489650236092 + }, + { + "step": 2620, + "lr": 0.0001, + "sup_loss": 2.1975032913281503 + }, + { + "step": 2621, + "lr": 0.0001, + "sup_loss": 2.1974918036200615 + }, + { + "step": 2622, + "lr": 0.0001, + "sup_loss": 2.1974512381895215 + }, + { + "step": 2623, + "lr": 0.0001, + "sup_loss": 2.1974453150698876 + }, + { + "step": 2624, + "lr": 0.0001, + "sup_loss": 2.197479356116646 + }, + { + "step": 2625, + "lr": 0.0001, + "sup_loss": 2.1975090132898463 + }, + { + "step": 2626, + "lr": 0.0001, + "sup_loss": 2.197430008441971 + }, + { + "step": 2627, + "lr": 0.0001, + "sup_loss": 2.1974345143774707 + }, + { + "step": 2628, + "lr": 0.0001, + "sup_loss": 2.1974498744017823 + }, + { + "step": 2629, + "lr": 0.0001, + "sup_loss": 2.197479085513554 + }, + { + "step": 2630, + "lr": 0.0001, + "sup_loss": 2.1974505161597904 + }, + { + "step": 2631, + "lr": 0.0001, + "sup_loss": 2.1974877419461274 + }, + { + "step": 2632, + "lr": 0.0001, + "sup_loss": 2.1975053928617463 + }, + { + "step": 2633, + "lr": 0.0001, + "sup_loss": 2.1974572063649984 + }, + { + "step": 2634, + "lr": 0.0001, + "sup_loss": 2.197555526546381 + }, + { + "step": 2635, + "lr": 0.0001, + "sup_loss": 2.1974668228278826 + }, + { + "step": 2636, + "lr": 0.0001, + "sup_loss": 2.1974564116036897 + }, + { + "step": 2637, + "lr": 0.0001, + "sup_loss": 2.1974445992408174 + }, + { + "step": 2638, + "lr": 0.0001, + "sup_loss": 2.197467978384532 + }, + { + "step": 2639, + "lr": 0.0001, + "sup_loss": 2.1974597127873126 + }, + { + "step": 2640, + "lr": 0.0001, + "sup_loss": 2.1974477335025338 + }, + { + "step": 2641, + "lr": 0.0001, + "sup_loss": 2.19748850118481 + }, + { + "step": 2642, + "lr": 0.0001, + "sup_loss": 2.1974506147895814 + }, + { + "step": 2643, + "lr": 0.0001, + "sup_loss": 2.197415902735398 + }, + { + "step": 2644, + "lr": 0.0001, + "sup_loss": 2.1974262635417956 + }, + { + "step": 2645, + "lr": 0.0001, + "sup_loss": 2.1974686520832525 + }, + { + "step": 2646, + "lr": 0.0001, + "sup_loss": 2.197449941887262 + }, + { + "step": 2647, + "lr": 0.0001, + "sup_loss": 2.1974982110871504 + }, + { + "step": 2648, + "lr": 0.0001, + "sup_loss": 2.197497934667857 + }, + { + "step": 2649, + "lr": 0.0001, + "sup_loss": 2.197473810923355 + }, + { + "step": 2650, + "lr": 0.0001, + "sup_loss": 2.19745804911713 + }, + { + "step": 2651, + "lr": 0.0001, + "sup_loss": 2.197538522091844 + }, + { + "step": 2652, + "lr": 0.0001, + "sup_loss": 2.197454675885866 + }, + { + "step": 2653, + "lr": 0.0001, + "sup_loss": 2.197461247185297 + }, + { + "step": 2654, + "lr": 0.0001, + "sup_loss": 2.197446849106951 + }, + { + "step": 2655, + "lr": 0.0001, + "sup_loss": 2.19746382958419 + }, + { + "step": 2656, + "lr": 0.0001, + "sup_loss": 2.1974464876942297 + }, + { + "step": 2657, + "lr": 0.0001, + "sup_loss": 2.197494921633893 + }, + { + "step": 2658, + "lr": 0.0001, + "sup_loss": 2.1975061076238105 + }, + { + "step": 2659, + "lr": 0.0001, + "sup_loss": 2.197389273163523 + }, + { + "step": 2660, + "lr": 0.0001, + "sup_loss": 2.1974242521484992 + }, + { + "step": 2661, + "lr": 0.0001, + "sup_loss": 2.1974835361862475 + }, + { + "step": 2662, + "lr": 0.0001, + "sup_loss": 2.1974512759183114 + }, + { + "step": 2663, + "lr": 0.0001, + "sup_loss": 2.197454645569952 + }, + { + "step": 2664, + "lr": 0.0001, + "sup_loss": 2.1975340279237194 + }, + { + "step": 2665, + "lr": 0.0001, + "sup_loss": 2.1975189056045723 + }, + { + "step": 2666, + "lr": 0.0001, + "sup_loss": 2.1975251958816484 + }, + { + "step": 2667, + "lr": 0.0001, + "sup_loss": 2.197420781516586 + }, + { + "step": 2668, + "lr": 0.0001, + "sup_loss": 2.1974531720147317 + }, + { + "step": 2669, + "lr": 0.0001, + "sup_loss": 2.197480200955501 + }, + { + "step": 2670, + "lr": 0.0001, + "sup_loss": 2.1975144416387584 + }, + { + "step": 2671, + "lr": 0.0001, + "sup_loss": 2.197455900190699 + }, + { + "step": 2672, + "lr": 0.0001, + "sup_loss": 2.1975020550381306 + }, + { + "step": 2673, + "lr": 0.0001, + "sup_loss": 2.1974870584103714 + }, + { + "step": 2674, + "lr": 0.0001, + "sup_loss": 2.197458101324217 + }, + { + "step": 2675, + "lr": 0.0001, + "sup_loss": 2.1975563902747997 + }, + { + "step": 2676, + "lr": 0.0001, + "sup_loss": 2.1974689545914035 + }, + { + "step": 2677, + "lr": 0.0001, + "sup_loss": 2.1974391627092844 + }, + { + "step": 2678, + "lr": 0.0001, + "sup_loss": 2.197491481782973 + }, + { + "step": 2679, + "lr": 0.0001, + "sup_loss": 2.197453929721619 + }, + { + "step": 2680, + "lr": 0.0001, + "sup_loss": 2.1974929387477182 + }, + { + "step": 2681, + "lr": 0.0001, + "sup_loss": 2.197500286426469 + }, + { + "step": 2682, + "lr": 0.0001, + "sup_loss": 2.1974649662064643 + }, + { + "step": 2683, + "lr": 0.0001, + "sup_loss": 2.1974324538812473 + }, + { + "step": 2684, + "lr": 0.0001, + "sup_loss": 2.1974271708268267 + }, + { + "step": 2685, + "lr": 0.0001, + "sup_loss": 2.197467287412647 + }, + { + "step": 2686, + "lr": 0.0001, + "sup_loss": 2.1975402393765675 + }, + { + "step": 2687, + "lr": 0.0001, + "sup_loss": 2.1973964722065094 + }, + { + "step": 2688, + "lr": 0.0001, + "sup_loss": 2.1974900025114756 + }, + { + "step": 2689, + "lr": 0.0001, + "sup_loss": 2.197457946454067 + }, + { + "step": 2690, + "lr": 0.0001, + "sup_loss": 2.197483439429578 + }, + { + "step": 2691, + "lr": 0.0001, + "sup_loss": 2.1974396714159794 + }, + { + "step": 2692, + "lr": 0.0001, + "sup_loss": 2.19747766901278 + }, + { + "step": 2693, + "lr": 0.0001, + "sup_loss": 2.1974558875054955 + }, + { + "step": 2694, + "lr": 0.0001, + "sup_loss": 2.1974476361706277 + }, + { + "step": 2695, + "lr": 0.0001, + "sup_loss": 2.1974868293011185 + }, + { + "step": 2696, + "lr": 0.0001, + "sup_loss": 2.197438129221513 + }, + { + "step": 2697, + "lr": 0.0001, + "sup_loss": 2.1974442015720816 + }, + { + "step": 2698, + "lr": 0.0001, + "sup_loss": 2.1974983560352523 + }, + { + "step": 2699, + "lr": 0.0001, + "sup_loss": 2.1974531533523436 + }, + { + "step": 2700, + "lr": 0.0001, + "sup_loss": 2.197496644678273 + }, + { + "step": 2701, + "lr": 0.0001, + "sup_loss": 2.197452296443396 + }, + { + "step": 2702, + "lr": 0.0001, + "sup_loss": 2.1974164930818203 + }, + { + "step": 2703, + "lr": 0.0001, + "sup_loss": 2.1975691165182423 + }, + { + "step": 2704, + "lr": 0.0001, + "sup_loss": 2.197505186692414 + }, + { + "step": 2705, + "lr": 0.0001, + "sup_loss": 2.19748012877525 + }, + { + "step": 2706, + "lr": 0.0001, + "sup_loss": 2.197449043720618 + }, + { + "step": 2707, + "lr": 0.0001, + "sup_loss": 2.197437263427494 + }, + { + "step": 2708, + "lr": 0.0001, + "sup_loss": 2.1974642855844246 + }, + { + "step": 2709, + "lr": 0.0001, + "sup_loss": 2.1974432239522947 + }, + { + "step": 2710, + "lr": 0.0001, + "sup_loss": 2.1974860743488804 + }, + { + "step": 2711, + "lr": 0.0001, + "sup_loss": 2.197398133109741 + }, + { + "step": 2712, + "lr": 0.0001, + "sup_loss": 2.1974561861528117 + }, + { + "step": 2713, + "lr": 0.0001, + "sup_loss": 2.197458412643413 + }, + { + "step": 2714, + "lr": 0.0001, + "sup_loss": 2.1974649553833374 + }, + { + "step": 2715, + "lr": 0.0001, + "sup_loss": 2.1974638474902575 + }, + { + "step": 2716, + "lr": 0.0001, + "sup_loss": 2.1974555160883273 + }, + { + "step": 2717, + "lr": 0.0001, + "sup_loss": 2.1974748379556104 + }, + { + "step": 2718, + "lr": 0.0001, + "sup_loss": 2.197453201041481 + }, + { + "step": 2719, + "lr": 0.0001, + "sup_loss": 2.1974569561160333 + }, + { + "step": 2720, + "lr": 0.0001, + "sup_loss": 2.1974686391410163 + }, + { + "step": 2721, + "lr": 0.0001, + "sup_loss": 2.197504395579611 + }, + { + "step": 2722, + "lr": 0.0001, + "sup_loss": 2.197484614443853 + }, + { + "step": 2723, + "lr": 0.0001, + "sup_loss": 2.1974408451980785 + }, + { + "step": 2724, + "lr": 0.0001, + "sup_loss": 2.1974393270232495 + }, + { + "step": 2725, + "lr": 0.0001, + "sup_loss": 2.1974876809425816 + }, + { + "step": 2726, + "lr": 0.0001, + "sup_loss": 2.1974964051509156 + }, + { + "step": 2727, + "lr": 0.0001, + "sup_loss": 2.197416791320345 + }, + { + "step": 2728, + "lr": 0.0001, + "sup_loss": 2.197492534514747 + }, + { + "step": 2729, + "lr": 0.0001, + "sup_loss": 2.197438200131532 + }, + { + "step": 2730, + "lr": 0.0001, + "sup_loss": 2.1975163411416707 + }, + { + "step": 2731, + "lr": 0.0001, + "sup_loss": 2.1974619576539274 + }, + { + "step": 2732, + "lr": 0.0001, + "sup_loss": 2.19754964362589 + }, + { + "step": 2733, + "lr": 0.0001, + "sup_loss": 2.197472968796119 + }, + { + "step": 2734, + "lr": 0.0001, + "sup_loss": 2.197495591727412 + }, + { + "step": 2735, + "lr": 0.0001, + "sup_loss": 2.197478932820908 + }, + { + "step": 2736, + "lr": 0.0001, + "sup_loss": 2.1975065118177595 + }, + { + "step": 2737, + "lr": 0.0001, + "sup_loss": 2.197479101391202 + }, + { + "step": 2738, + "lr": 0.0001, + "sup_loss": 2.1974534377792247 + }, + { + "step": 2739, + "lr": 0.0001, + "sup_loss": 2.1974968618171715 + }, + { + "step": 2740, + "lr": 0.0001, + "sup_loss": 2.197485188952018 + }, + { + "step": 2741, + "lr": 0.0001, + "sup_loss": 2.1974086728815156 + }, + { + "step": 2742, + "lr": 0.0001, + "sup_loss": 2.1975051159529815 + }, + { + "step": 2743, + "lr": 0.0001, + "sup_loss": 2.1974628145918973 + }, + { + "step": 2744, + "lr": 0.0001, + "sup_loss": 2.1974706441512093 + }, + { + "step": 2745, + "lr": 0.0001, + "sup_loss": 2.1974744427309783 + }, + { + "step": 2746, + "lr": 0.0001, + "sup_loss": 2.1974412321144134 + }, + { + "step": 2747, + "lr": 0.0001, + "sup_loss": 2.1974643288121607 + }, + { + "step": 2748, + "lr": 0.0001, + "sup_loss": 2.1974984926986614 + }, + { + "step": 2749, + "lr": 0.0001, + "sup_loss": 2.1974536506376072 + }, + { + "step": 2750, + "lr": 0.0001, + "sup_loss": 2.19746043023741 + }, + { + "step": 2751, + "lr": 0.0001, + "sup_loss": 2.1975639779471905 + }, + { + "step": 2752, + "lr": 0.0001, + "sup_loss": 2.1974419179434688 + }, + { + "step": 2753, + "lr": 0.0001, + "sup_loss": 2.1975100298907315 + }, + { + "step": 2754, + "lr": 0.0001, + "sup_loss": 2.1974479130251154 + }, + { + "step": 2755, + "lr": 0.0001, + "sup_loss": 2.1975125651445695 + }, + { + "step": 2756, + "lr": 0.0001, + "sup_loss": 2.197446516539981 + }, + { + "step": 2757, + "lr": 0.0001, + "sup_loss": 2.197439599798592 + }, + { + "step": 2758, + "lr": 0.0001, + "sup_loss": 2.1974603336032126 + }, + { + "step": 2759, + "lr": 0.0001, + "sup_loss": 2.1975007926260663 + }, + { + "step": 2760, + "lr": 0.0001, + "sup_loss": 2.197455290810639 + }, + { + "step": 2761, + "lr": 0.0001, + "sup_loss": 2.1974776065491923 + }, + { + "step": 2762, + "lr": 0.0001, + "sup_loss": 2.197434175023034 + }, + { + "step": 2763, + "lr": 0.0001, + "sup_loss": 2.197529374029343 + }, + { + "step": 2764, + "lr": 0.0001, + "sup_loss": 2.1974530713870752 + }, + { + "step": 2765, + "lr": 0.0001, + "sup_loss": 2.1974720588381924 + }, + { + "step": 2766, + "lr": 0.0001, + "sup_loss": 2.1974674622248838 + }, + { + "step": 2767, + "lr": 0.0001, + "sup_loss": 2.1974778003500113 + }, + { + "step": 2768, + "lr": 0.0001, + "sup_loss": 2.197415358810136 + }, + { + "step": 2769, + "lr": 0.0001, + "sup_loss": 2.197462934985504 + }, + { + "step": 2770, + "lr": 0.0001, + "sup_loss": 2.1974942879281625 + }, + { + "step": 2771, + "lr": 0.0001, + "sup_loss": 2.197546465232709 + }, + { + "step": 2772, + "lr": 0.0001, + "sup_loss": 2.1974319055012774 + }, + { + "step": 2773, + "lr": 0.0001, + "sup_loss": 2.197476352267313 + }, + { + "step": 2774, + "lr": 0.0001, + "sup_loss": 2.1974624029948138 + }, + { + "step": 2775, + "lr": 0.0001, + "sup_loss": 2.1974371824817887 + }, + { + "step": 2776, + "lr": 0.0001, + "sup_loss": 2.197491041211201 + }, + { + "step": 2777, + "lr": 0.0001, + "sup_loss": 2.197420379431279 + }, + { + "step": 2778, + "lr": 0.0001, + "sup_loss": 2.1974470320515276 + }, + { + "step": 2779, + "lr": 0.0001, + "sup_loss": 2.1974354983561453 + }, + { + "step": 2780, + "lr": 0.0001, + "sup_loss": 2.1974963425272787 + }, + { + "step": 2781, + "lr": 0.0001, + "sup_loss": 2.197447098432061 + }, + { + "step": 2782, + "lr": 0.0001, + "sup_loss": 2.1974784515609063 + }, + { + "step": 2783, + "lr": 0.0001, + "sup_loss": 2.1974717552256866 + }, + { + "step": 2784, + "lr": 0.0001, + "sup_loss": 2.197473027181285 + }, + { + "step": 2785, + "lr": 0.0001, + "sup_loss": 2.1974947648837557 + }, + { + "step": 2786, + "lr": 0.0001, + "sup_loss": 2.1974037400418305 + }, + { + "step": 2787, + "lr": 0.0001, + "sup_loss": 2.1974320545076695 + }, + { + "step": 2788, + "lr": 0.0001, + "sup_loss": 2.197466146880363 + }, + { + "step": 2789, + "lr": 0.0001, + "sup_loss": 2.197465429537357 + }, + { + "step": 2790, + "lr": 0.0001, + "sup_loss": 2.19744070396621 + }, + { + "step": 2791, + "lr": 0.0001, + "sup_loss": 2.197438014318882 + }, + { + "step": 2792, + "lr": 0.0001, + "sup_loss": 2.197477015177098 + }, + { + "step": 2793, + "lr": 0.0001, + "sup_loss": 2.1974786958438917 + }, + { + "step": 2794, + "lr": 0.0001, + "sup_loss": 2.1974849285654736 + }, + { + "step": 2795, + "lr": 0.0001, + "sup_loss": 2.197411175429069 + }, + { + "step": 2796, + "lr": 0.0001, + "sup_loss": 2.197452091414002 + }, + { + "step": 2797, + "lr": 0.0001, + "sup_loss": 2.197424805896044 + }, + { + "step": 2798, + "lr": 0.0001, + "sup_loss": 2.197488768050909 + }, + { + "step": 2799, + "lr": 0.0001, + "sup_loss": 2.1974910279686592 + }, + { + "step": 2800, + "lr": 0.0001, + "sup_loss": 2.197475702377125 + }, + { + "step": 2801, + "lr": 0.0001, + "sup_loss": 2.197497688068121 + }, + { + "step": 2802, + "lr": 0.0001, + "sup_loss": 2.197471541932217 + }, + { + "step": 2803, + "lr": 0.0001, + "sup_loss": 2.1974477155086154 + }, + { + "step": 2804, + "lr": 0.0001, + "sup_loss": 2.197476882319043 + }, + { + "step": 2805, + "lr": 0.0001, + "sup_loss": 2.1973825437378545 + }, + { + "step": 2806, + "lr": 0.0001, + "sup_loss": 2.197520608481497 + }, + { + "step": 2807, + "lr": 0.0001, + "sup_loss": 2.1974686714922544 + }, + { + "step": 2808, + "lr": 0.0001, + "sup_loss": 2.1974433591156135 + }, + { + "step": 2809, + "lr": 0.0001, + "sup_loss": 2.1974366366447575 + }, + { + "step": 2810, + "lr": 0.0001, + "sup_loss": 2.197426830403122 + }, + { + "step": 2811, + "lr": 0.0001, + "sup_loss": 2.1974505771770003 + }, + { + "step": 2812, + "lr": 0.0001, + "sup_loss": 2.1975073962318525 + }, + { + "step": 2813, + "lr": 0.0001, + "sup_loss": 2.197466326457407 + }, + { + "step": 2814, + "lr": 0.0001, + "sup_loss": 2.1975043398004814 + }, + { + "step": 2815, + "lr": 0.0001, + "sup_loss": 2.197450681610317 + }, + { + "step": 2816, + "lr": 0.0001, + "sup_loss": 2.1974975885070456 + }, + { + "step": 2817, + "lr": 0.0001, + "sup_loss": 2.1974459950674006 + }, + { + "step": 2818, + "lr": 0.0001, + "sup_loss": 2.1974615797043766 + }, + { + "step": 2819, + "lr": 0.0001, + "sup_loss": 2.197453092480091 + }, + { + "step": 2820, + "lr": 0.0001, + "sup_loss": 2.197497229169771 + }, + { + "step": 2821, + "lr": 0.0001, + "sup_loss": 2.1974321693755603 + }, + { + "step": 2822, + "lr": 0.0001, + "sup_loss": 2.197503469988333 + }, + { + "step": 2823, + "lr": 0.0001, + "sup_loss": 2.1974129479478384 + }, + { + "step": 2824, + "lr": 0.0001, + "sup_loss": 2.197442592675248 + }, + { + "step": 2825, + "lr": 0.0001, + "sup_loss": 2.197439167942528 + }, + { + "step": 2826, + "lr": 0.0001, + "sup_loss": 2.1974317785947663 + }, + { + "step": 2827, + "lr": 0.0001, + "sup_loss": 2.1974476222816035 + }, + { + "step": 2828, + "lr": 0.0001, + "sup_loss": 2.197482878539677 + }, + { + "step": 2829, + "lr": 0.0001, + "sup_loss": 2.197464343717016 + }, + { + "step": 2830, + "lr": 0.0001, + "sup_loss": 2.1974401878307215 + }, + { + "step": 2831, + "lr": 0.0001, + "sup_loss": 2.1975112985124396 + }, + { + "step": 2832, + "lr": 0.0001, + "sup_loss": 2.197460649084561 + }, + { + "step": 2833, + "lr": 0.0001, + "sup_loss": 2.197368065640363 + }, + { + "step": 2834, + "lr": 0.0001, + "sup_loss": 2.197480865288469 + }, + { + "step": 2835, + "lr": 0.0001, + "sup_loss": 2.1974942368060577 + }, + { + "step": 2836, + "lr": 0.0001, + "sup_loss": 2.1974886749822877 + }, + { + "step": 2837, + "lr": 0.0001, + "sup_loss": 2.197435497233727 + }, + { + "step": 2838, + "lr": 0.0001, + "sup_loss": 2.1974675487565785 + }, + { + "step": 2839, + "lr": 0.0001, + "sup_loss": 2.1974927099633788 + }, + { + "step": 2840, + "lr": 0.0001, + "sup_loss": 2.1974661381040512 + }, + { + "step": 2841, + "lr": 0.0001, + "sup_loss": 2.1975047889447765 + }, + { + "step": 2842, + "lr": 0.0001, + "sup_loss": 2.1974780715736157 + }, + { + "step": 2843, + "lr": 0.0001, + "sup_loss": 2.1974534351209996 + }, + { + "step": 2844, + "lr": 0.0001, + "sup_loss": 2.197403236605091 + }, + { + "step": 2845, + "lr": 0.0001, + "sup_loss": 2.1974739748891814 + }, + { + "step": 2846, + "lr": 0.0001, + "sup_loss": 2.1974553454884598 + }, + { + "step": 2847, + "lr": 0.0001, + "sup_loss": 2.197486137754388 + }, + { + "step": 2848, + "lr": 0.0001, + "sup_loss": 2.1974114324718013 + }, + { + "step": 2849, + "lr": 0.0001, + "sup_loss": 2.1974206424914926 + }, + { + "step": 2850, + "lr": 0.0001, + "sup_loss": 2.197484781406074 + }, + { + "step": 2851, + "lr": 0.0001, + "sup_loss": 2.197474385565335 + }, + { + "step": 2852, + "lr": 0.0001, + "sup_loss": 2.1974303660859063 + }, + { + "step": 2853, + "lr": 0.0001, + "sup_loss": 2.1975165432964716 + }, + { + "step": 2854, + "lr": 0.0001, + "sup_loss": 2.197435751575816 + }, + { + "step": 2855, + "lr": 0.0001, + "sup_loss": 2.1974812239048864 + }, + { + "step": 2856, + "lr": 0.0001, + "sup_loss": 2.1974751259416587 + }, + { + "step": 2857, + "lr": 0.0001, + "sup_loss": 2.197450354286775 + }, + { + "step": 2858, + "lr": 0.0001, + "sup_loss": 2.1974417115758063 + }, + { + "step": 2859, + "lr": 0.0001, + "sup_loss": 2.197465684605838 + }, + { + "step": 2860, + "lr": 0.0001, + "sup_loss": 2.1974087990172104 + }, + { + "step": 2861, + "lr": 0.0001, + "sup_loss": 2.1974016387307804 + }, + { + "step": 2862, + "lr": 0.0001, + "sup_loss": 2.1974566798523467 + }, + { + "step": 2863, + "lr": 0.0001, + "sup_loss": 2.197402074842922 + }, + { + "step": 2864, + "lr": 0.0001, + "sup_loss": 2.197444286677209 + }, + { + "step": 2865, + "lr": 0.0001, + "sup_loss": 2.197461887267418 + }, + { + "step": 2866, + "lr": 0.0001, + "sup_loss": 2.1973980293800435 + }, + { + "step": 2867, + "lr": 0.0001, + "sup_loss": 2.1974632688779687 + }, + { + "step": 2868, + "lr": 0.0001, + "sup_loss": 2.197405763240146 + }, + { + "step": 2869, + "lr": 0.0001, + "sup_loss": 2.197480188565047 + }, + { + "step": 2870, + "lr": 0.0001, + "sup_loss": 2.197444012153067 + }, + { + "step": 2871, + "lr": 0.0001, + "sup_loss": 2.1974616872139476 + }, + { + "step": 2872, + "lr": 0.0001, + "sup_loss": 2.1975088294588634 + }, + { + "step": 2873, + "lr": 0.0001, + "sup_loss": 2.1974201716419035 + }, + { + "step": 2874, + "lr": 0.0001, + "sup_loss": 2.19748397548035 + }, + { + "step": 2875, + "lr": 0.0001, + "sup_loss": 2.197457673506566 + }, + { + "step": 2876, + "lr": 0.0001, + "sup_loss": 2.197421414023234 + }, + { + "step": 2877, + "lr": 0.0001, + "sup_loss": 2.197470359650615 + }, + { + "step": 2878, + "lr": 0.0001, + "sup_loss": 2.197456692362497 + }, + { + "step": 2879, + "lr": 0.0001, + "sup_loss": 2.1975059010801807 + }, + { + "step": 2880, + "lr": 0.0001, + "sup_loss": 2.197480584755902 + }, + { + "step": 2881, + "lr": 0.0001, + "sup_loss": 2.197492115841772 + }, + { + "step": 2882, + "lr": 0.0001, + "sup_loss": 2.1974456524535464 + }, + { + "step": 2883, + "lr": 0.0001, + "sup_loss": 2.197409823886162 + }, + { + "step": 2884, + "lr": 0.0001, + "sup_loss": 2.197447056352813 + }, + { + "step": 2885, + "lr": 0.0001, + "sup_loss": 2.1974880100894674 + }, + { + "step": 2886, + "lr": 0.0001, + "sup_loss": 2.197380564470063 + }, + { + "step": 2887, + "lr": 0.0001, + "sup_loss": 2.1974175708706776 + }, + { + "step": 2888, + "lr": 0.0001, + "sup_loss": 2.1974648987395216 + }, + { + "step": 2889, + "lr": 0.0001, + "sup_loss": 2.19742656181532 + }, + { + "step": 2890, + "lr": 0.0001, + "sup_loss": 2.197445674734988 + }, + { + "step": 2891, + "lr": 0.0001, + "sup_loss": 2.1974616103228035 + }, + { + "step": 2892, + "lr": 0.0001, + "sup_loss": 2.1974531703328957 + }, + { + "step": 2893, + "lr": 0.0001, + "sup_loss": 2.1974639979472106 + }, + { + "step": 2894, + "lr": 0.0001, + "sup_loss": 2.197403185112944 + }, + { + "step": 2895, + "lr": 0.0001, + "sup_loss": 2.197402769439198 + }, + { + "step": 2896, + "lr": 0.0001, + "sup_loss": 2.197419349093192 + }, + { + "step": 2897, + "lr": 0.0001, + "sup_loss": 2.197472179859693 + }, + { + "step": 2898, + "lr": 0.0001, + "sup_loss": 2.197487520069981 + }, + { + "step": 2899, + "lr": 0.0001, + "sup_loss": 2.197435435650301 + }, + { + "step": 2900, + "lr": 0.0001, + "sup_loss": 2.197409030403217 + }, + { + "step": 2901, + "lr": 0.0001, + "sup_loss": 2.197428305783502 + }, + { + "step": 2902, + "lr": 0.0001, + "sup_loss": 2.197438328752114 + }, + { + "step": 2903, + "lr": 0.0001, + "sup_loss": 2.197448583479259 + }, + { + "step": 2904, + "lr": 0.0001, + "sup_loss": 2.1974025269391024 + }, + { + "step": 2905, + "lr": 0.0001, + "sup_loss": 2.197484515081147 + }, + { + "step": 2906, + "lr": 0.0001, + "sup_loss": 2.1974338162697484 + }, + { + "step": 2907, + "lr": 0.0001, + "sup_loss": 2.197431244081963 + }, + { + "step": 2908, + "lr": 0.0001, + "sup_loss": 2.197445395947598 + }, + { + "step": 2909, + "lr": 0.0001, + "sup_loss": 2.197456374851158 + }, + { + "step": 2910, + "lr": 0.0001, + "sup_loss": 2.197456516129391 + }, + { + "step": 2911, + "lr": 0.0001, + "sup_loss": 2.1974319418155837 + }, + { + "step": 2912, + "lr": 0.0001, + "sup_loss": 2.197446563800873 + }, + { + "step": 2913, + "lr": 0.0001, + "sup_loss": 2.197463375928082 + }, + { + "step": 2914, + "lr": 0.0001, + "sup_loss": 2.197437633137408 + }, + { + "step": 2915, + "lr": 0.0001, + "sup_loss": 2.1975258288264667 + }, + { + "step": 2916, + "lr": 0.0001, + "sup_loss": 2.1974267674177552 + }, + { + "step": 2917, + "lr": 0.0001, + "sup_loss": 2.19742034411016 + }, + { + "step": 2918, + "lr": 0.0001, + "sup_loss": 2.197542787817668 + }, + { + "step": 2919, + "lr": 0.0001, + "sup_loss": 2.1974014675165443 + }, + { + "step": 2920, + "lr": 0.0001, + "sup_loss": 2.197419655471117 + }, + { + "step": 2921, + "lr": 0.0001, + "sup_loss": 2.197462828734899 + }, + { + "step": 2922, + "lr": 0.0001, + "sup_loss": 2.1974721885820925 + }, + { + "step": 2923, + "lr": 0.0001, + "sup_loss": 2.1974311379711304 + }, + { + "step": 2924, + "lr": 0.0001, + "sup_loss": 2.1974391369073696 + }, + { + "step": 2925, + "lr": 0.0001, + "sup_loss": 2.1974622968285713 + }, + { + "step": 2926, + "lr": 0.0001, + "sup_loss": 2.197475718311705 + }, + { + "step": 2927, + "lr": 0.0001, + "sup_loss": 2.1973798121935406 + }, + { + "step": 2928, + "lr": 0.0001, + "sup_loss": 2.197421325822916 + }, + { + "step": 2929, + "lr": 0.0001, + "sup_loss": 2.1975080243958027 + }, + { + "step": 2930, + "lr": 0.0001, + "sup_loss": 2.1974677568064855 + }, + { + "step": 2931, + "lr": 0.0001, + "sup_loss": 2.19741895407991 + }, + { + "step": 2932, + "lr": 0.0001, + "sup_loss": 2.19739101740239 + }, + { + "step": 2933, + "lr": 0.0001, + "sup_loss": 2.197397645312997 + }, + { + "step": 2934, + "lr": 0.0001, + "sup_loss": 2.197453266227704 + }, + { + "step": 2935, + "lr": 0.0001, + "sup_loss": 2.1974327378540117 + }, + { + "step": 2936, + "lr": 0.0001, + "sup_loss": 2.1974205721174807 + }, + { + "step": 2937, + "lr": 0.0001, + "sup_loss": 2.1974257653948888 + }, + { + "step": 2938, + "lr": 0.0001, + "sup_loss": 2.197457879503047 + }, + { + "step": 2939, + "lr": 0.0001, + "sup_loss": 2.197447740044953 + }, + { + "step": 2940, + "lr": 0.0001, + "sup_loss": 2.1974396596271353 + }, + { + "step": 2941, + "lr": 0.0001, + "sup_loss": 2.1974483015897377 + }, + { + "step": 2942, + "lr": 0.0001, + "sup_loss": 2.197450370419054 + }, + { + "step": 2943, + "lr": 0.0001, + "sup_loss": 2.1974343204009417 + }, + { + "step": 2944, + "lr": 0.0001, + "sup_loss": 2.1974155331783782 + }, + { + "step": 2945, + "lr": 0.0001, + "sup_loss": 2.1974219196978386 + }, + { + "step": 2946, + "lr": 0.0001, + "sup_loss": 2.1974966580651865 + }, + { + "step": 2947, + "lr": 0.0001, + "sup_loss": 2.1974746818871544 + }, + { + "step": 2948, + "lr": 0.0001, + "sup_loss": 2.1974413444846883 + }, + { + "step": 2949, + "lr": 0.0001, + "sup_loss": 2.1974443490779705 + }, + { + "step": 2950, + "lr": 0.0001, + "sup_loss": 2.197443905465411 + }, + { + "step": 2951, + "lr": 0.0001, + "sup_loss": 2.19741173195058 + }, + { + "step": 2952, + "lr": 0.0001, + "sup_loss": 2.1974210148393913 + }, + { + "step": 2953, + "lr": 0.0001, + "sup_loss": 2.1974276794150125 + }, + { + "step": 2954, + "lr": 0.0001, + "sup_loss": 2.197417883527537 + }, + { + "step": 2955, + "lr": 0.0001, + "sup_loss": 2.1974292219813867 + }, + { + "step": 2956, + "lr": 0.0001, + "sup_loss": 2.1974290592297003 + }, + { + "step": 2957, + "lr": 0.0001, + "sup_loss": 2.1974340591317882 + }, + { + "step": 2958, + "lr": 0.0001, + "sup_loss": 2.197434690654158 + }, + { + "step": 2959, + "lr": 0.0001, + "sup_loss": 2.1974060374616307 + }, + { + "step": 2960, + "lr": 0.0001, + "sup_loss": 2.1973793152001386 + }, + { + "step": 2961, + "lr": 0.0001, + "sup_loss": 2.1974255016576034 + }, + { + "step": 2962, + "lr": 0.0001, + "sup_loss": 2.197420559064537 + }, + { + "step": 2963, + "lr": 0.0001, + "sup_loss": 2.1974150160478736 + }, + { + "step": 2964, + "lr": 0.0001, + "sup_loss": 2.197445364547914 + }, + { + "step": 2965, + "lr": 0.0001, + "sup_loss": 2.1974370083155206 + }, + { + "step": 2966, + "lr": 0.0001, + "sup_loss": 2.19740476348719 + }, + { + "step": 2967, + "lr": 0.0001, + "sup_loss": 2.1974283174957843 + }, + { + "step": 2968, + "lr": 0.0001, + "sup_loss": 2.1974485305672773 + }, + { + "step": 2969, + "lr": 0.0001, + "sup_loss": 2.197432188150042 + }, + { + "step": 2970, + "lr": 0.0001, + "sup_loss": 2.197426585969617 + }, + { + "step": 2971, + "lr": 0.0001, + "sup_loss": 2.1974422065204195 + }, + { + "step": 2972, + "lr": 0.0001, + "sup_loss": 2.1974382107754415 + }, + { + "step": 2973, + "lr": 0.0001, + "sup_loss": 2.1974302847145104 + }, + { + "step": 2974, + "lr": 0.0001, + "sup_loss": 2.1974330622237823 + }, + { + "step": 2975, + "lr": 0.0001, + "sup_loss": 2.1974507142646127 + }, + { + "step": 2976, + "lr": 0.0001, + "sup_loss": 2.197436715379992 + }, + { + "step": 2977, + "lr": 0.0001, + "sup_loss": 2.1973954788528847 + }, + { + "step": 2978, + "lr": 0.0001, + "sup_loss": 2.197357856751435 + }, + { + "step": 2979, + "lr": 0.0001, + "sup_loss": 2.19747203371913 + }, + { + "step": 2980, + "lr": 0.0001, + "sup_loss": 2.197459291146453 + }, + { + "step": 2981, + "lr": 0.0001, + "sup_loss": 2.197415261787257 + }, + { + "step": 2982, + "lr": 0.0001, + "sup_loss": 2.1974214503039597 + }, + { + "step": 2983, + "lr": 0.0001, + "sup_loss": 2.1975362293896636 + }, + { + "step": 2984, + "lr": 0.0001, + "sup_loss": 2.19739856904649 + }, + { + "step": 2985, + "lr": 0.0001, + "sup_loss": 2.197461120490005 + }, + { + "step": 2986, + "lr": 0.0001, + "sup_loss": 2.1974050800549754 + }, + { + "step": 2987, + "lr": 0.0001, + "sup_loss": 2.197391774783016 + }, + { + "step": 2988, + "lr": 0.0001, + "sup_loss": 2.1974345858758335 + }, + { + "step": 2989, + "lr": 0.0001, + "sup_loss": 2.197431481612429 + }, + { + "step": 2990, + "lr": 0.0001, + "sup_loss": 2.1974824020613637 + }, + { + "step": 2991, + "lr": 0.0001, + "sup_loss": 2.1974017724404042 + }, + { + "step": 2992, + "lr": 0.0001, + "sup_loss": 2.1973680621886063 + }, + { + "step": 2993, + "lr": 0.0001, + "sup_loss": 2.1974357431466163 + }, + { + "step": 2994, + "lr": 0.0001, + "sup_loss": 2.197463403369533 + }, + { + "step": 2995, + "lr": 0.0001, + "sup_loss": 2.197425096484156 + }, + { + "step": 2996, + "lr": 0.0001, + "sup_loss": 2.1974055398293983 + }, + { + "step": 2997, + "lr": 0.0001, + "sup_loss": 2.1974773980079574 + }, + { + "step": 2998, + "lr": 0.0001, + "sup_loss": 2.197433863080439 + }, + { + "step": 2999, + "lr": 0.0001, + "sup_loss": 2.1974369341330204 + } + ], + "evals": [ + { + "step": 0, + "acc": 0.0, + "tok_acc": 0.1111111111111111 + }, + { + "step": 300, + "acc": 0.0, + "tok_acc": 0.1111111111111111 + }, + { + "step": 600, + "acc": 0.0, + "tok_acc": 0.11135223765432099 + }, + { + "step": 900, + "acc": 0.0, + "tok_acc": 0.11166570216049383 + }, + { + "step": 1200, + "acc": 0.0, + "tok_acc": 0.11050829475308642 + }, + { + "step": 1500, + "acc": 0.0, + "tok_acc": 0.11140046296296297 + }, + { + "step": 1800, + "acc": 0.0, + "tok_acc": 0.11118344907407407 + }, + { + "step": 2100, + "acc": 0.0, + "tok_acc": 0.11103877314814815 + }, + { + "step": 2400, + "acc": 0.0, + "tok_acc": 0.111328125 + }, + { + "step": 2700, + "acc": 0.0, + "tok_acc": 0.11082175925925926 + }, + { + "step": 3000, + "acc": 0.0, + "tok_acc": 0.11147280092592593 + } + ], + "final_acc": 0.0, + "final_tok_acc": 0.11147280092592593 +}
\ No newline at end of file diff --git a/srm/runs/srm_aol_v1_sudoku1k_3k.json b/srm/runs/srm_aol_v1_sudoku1k_3k.json new file mode 100644 index 0000000..4944806 --- /dev/null +++ b/srm/runs/srm_aol_v1_sudoku1k_3k.json @@ -0,0 +1,15517 @@ +{ + "args": { + "data_path": "/home/yurenh2/rrm/data/sudoku-extreme-1k-aug-1000", + "n_steps": 3000, + "batch_size": 8, + "lr": 0.0001, + "puzzle_emb_lr": 0.0001, + "warmup_steps": 200, + "weight_decay": 1.0, + "hidden_size": 512, + "n_iters": 12, + "n_aol_layers": 2, + "kappa": 0.9, + "eta": 1.0, + "alpha": 1.0, + "k_lyap": 2, + "lyap_iters": 8, + "lyap_every": 50, + "seed": 42, + "eval_every": 300, + "eval_n": 512, + "eval_batch_size": 32, + "out": "runs/srm_aol_v1_sudoku1k_3k.json", + "save_ckpt": "ckpts/srm_aol_v1_3k.pt" + }, + "n_params": 3700018, + "initial_acc": 0.0, + "initial_tok_acc": 0.11108699845679013, + "initial_lip": { + "lip_emp_mean": 0.09653933346271515, + "lip_emp_max": 0.1220538467168808, + "lip_emp_99p": 0.12071612477302551, + "lip_theoretical_bound": 0.9, + "passes_bound": true + }, + "steps": [ + { + "step": 0, + "lr": 0.0, + "sup_loss": 2.6486240918413437, + "lyap1_mean": -6.549736022949219, + "lyap1_max": -6.539831161499023, + "lyap_spec_mean": [ + -6.549736022949219, + -6.549976348876953 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1, + "lr": 5e-07, + "sup_loss": 2.66581192100626 + }, + { + "step": 2, + "lr": 1e-06, + "sup_loss": 2.6551254999064735 + }, + { + "step": 3, + "lr": 1.5e-06, + "sup_loss": 2.6923477307570765 + }, + { + "step": 4, + "lr": 2e-06, + "sup_loss": 2.645281303080112 + }, + { + "step": 5, + "lr": 2.5e-06, + "sup_loss": 2.683779022703776 + }, + { + "step": 6, + "lr": 3e-06, + "sup_loss": 2.668961340068308 + }, + { + "step": 7, + "lr": 3.5e-06, + "sup_loss": 2.691453761754646 + }, + { + "step": 8, + "lr": 4e-06, + "sup_loss": 2.67131585905981 + }, + { + "step": 9, + "lr": 4.5e-06, + "sup_loss": 2.6396303064503073 + }, + { + "step": 10, + "lr": 5e-06, + "sup_loss": 2.6777360122204783 + }, + { + "step": 11, + "lr": 5.500000000000001e-06, + "sup_loss": 2.644418895220248 + }, + { + "step": 12, + "lr": 6e-06, + "sup_loss": 2.5983125688845425 + }, + { + "step": 13, + "lr": 6.5000000000000004e-06, + "sup_loss": 2.655729060731042 + }, + { + "step": 14, + "lr": 7e-06, + "sup_loss": 2.625770367908041 + }, + { + "step": 15, + "lr": 7.5e-06, + "sup_loss": 2.6155870751135746 + }, + { + "step": 16, + "lr": 8e-06, + "sup_loss": 2.5964094162748763 + }, + { + "step": 17, + "lr": 8.5e-06, + "sup_loss": 2.617146447229883 + }, + { + "step": 18, + "lr": 9e-06, + "sup_loss": 2.60610974842071 + }, + { + "step": 19, + "lr": 9.5e-06, + "sup_loss": 2.6014442318943773 + }, + { + "step": 20, + "lr": 1e-05, + "sup_loss": 2.5962810756013224 + }, + { + "step": 21, + "lr": 1.0500000000000001e-05, + "sup_loss": 2.6082165910390334 + }, + { + "step": 22, + "lr": 1.1000000000000001e-05, + "sup_loss": 2.553679666296391 + }, + { + "step": 23, + "lr": 1.15e-05, + "sup_loss": 2.571934004236155 + }, + { + "step": 24, + "lr": 1.2e-05, + "sup_loss": 2.5629419901326527 + }, + { + "step": 25, + "lr": 1.25e-05, + "sup_loss": 2.53322149097866 + }, + { + "step": 26, + "lr": 1.3000000000000001e-05, + "sup_loss": 2.5600389565491857 + }, + { + "step": 27, + "lr": 1.3500000000000001e-05, + "sup_loss": 2.5287331587153155 + }, + { + "step": 28, + "lr": 1.4e-05, + "sup_loss": 2.4996639796202493 + }, + { + "step": 29, + "lr": 1.4500000000000002e-05, + "sup_loss": 2.4658839702933375 + }, + { + "step": 30, + "lr": 1.5e-05, + "sup_loss": 2.502888471186299 + }, + { + "step": 31, + "lr": 1.55e-05, + "sup_loss": 2.486028037755685 + }, + { + "step": 32, + "lr": 1.6e-05, + "sup_loss": 2.455803139363649 + }, + { + "step": 33, + "lr": 1.65e-05, + "sup_loss": 2.450766423850345 + }, + { + "step": 34, + "lr": 1.7e-05, + "sup_loss": 2.4599090138447104 + }, + { + "step": 35, + "lr": 1.7500000000000002e-05, + "sup_loss": 2.411981690314369 + }, + { + "step": 36, + "lr": 1.8e-05, + "sup_loss": 2.3960091921334774 + }, + { + "step": 37, + "lr": 1.8500000000000002e-05, + "sup_loss": 2.412117418660942 + }, + { + "step": 38, + "lr": 1.9e-05, + "sup_loss": 2.3877505016014466 + }, + { + "step": 39, + "lr": 1.95e-05, + "sup_loss": 2.3738033299289767 + }, + { + "step": 40, + "lr": 2e-05, + "sup_loss": 2.3774336792493087 + }, + { + "step": 41, + "lr": 2.05e-05, + "sup_loss": 2.3386668042199688 + }, + { + "step": 42, + "lr": 2.1000000000000002e-05, + "sup_loss": 2.323580736430218 + }, + { + "step": 43, + "lr": 2.15e-05, + "sup_loss": 2.3230888710275712 + }, + { + "step": 44, + "lr": 2.2000000000000003e-05, + "sup_loss": 2.2962211806303623 + }, + { + "step": 45, + "lr": 2.25e-05, + "sup_loss": 2.28249863397299 + }, + { + "step": 46, + "lr": 2.3e-05, + "sup_loss": 2.277612049889994 + }, + { + "step": 47, + "lr": 2.3500000000000002e-05, + "sup_loss": 2.274061397690501 + }, + { + "step": 48, + "lr": 2.4e-05, + "sup_loss": 2.2542018275664475 + }, + { + "step": 49, + "lr": 2.45e-05, + "sup_loss": 2.239544759545745 + }, + { + "step": 50, + "lr": 2.5e-05, + "sup_loss": 2.230678213861076, + "lyap1_mean": -6.591014862060547, + "lyap1_max": -6.573784828186035, + "lyap_spec_mean": [ + -6.591015815734863, + -6.592367649078369 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 51, + "lr": 2.5500000000000003e-05, + "sup_loss": 2.2250846620499685 + }, + { + "step": 52, + "lr": 2.6000000000000002e-05, + "sup_loss": 2.1904298900992263 + }, + { + "step": 53, + "lr": 2.65e-05, + "sup_loss": 2.1887838225160507 + }, + { + "step": 54, + "lr": 2.7000000000000002e-05, + "sup_loss": 2.175130077373692 + }, + { + "step": 55, + "lr": 2.7500000000000004e-05, + "sup_loss": 2.1657483386708676 + }, + { + "step": 56, + "lr": 2.8e-05, + "sup_loss": 2.1557390028955203 + }, + { + "step": 57, + "lr": 2.85e-05, + "sup_loss": 2.144618694787544 + }, + { + "step": 58, + "lr": 2.9000000000000004e-05, + "sup_loss": 2.1388971830385146 + }, + { + "step": 59, + "lr": 2.95e-05, + "sup_loss": 2.0973153612516695 + }, + { + "step": 60, + "lr": 3e-05, + "sup_loss": 2.113670049835654 + }, + { + "step": 61, + "lr": 3.0500000000000003e-05, + "sup_loss": 2.1207479296026577 + }, + { + "step": 62, + "lr": 3.1e-05, + "sup_loss": 2.082421628039469 + }, + { + "step": 63, + "lr": 3.15e-05, + "sup_loss": 2.070673099710961 + }, + { + "step": 64, + "lr": 3.2e-05, + "sup_loss": 2.0589569566583137 + }, + { + "step": 65, + "lr": 3.2500000000000004e-05, + "sup_loss": 2.070935305666071 + }, + { + "step": 66, + "lr": 3.3e-05, + "sup_loss": 2.0365844955544405 + }, + { + "step": 67, + "lr": 3.35e-05, + "sup_loss": 2.026026646992839 + }, + { + "step": 68, + "lr": 3.4e-05, + "sup_loss": 2.0246294504732814 + }, + { + "step": 69, + "lr": 3.4500000000000005e-05, + "sup_loss": 2.0130169588066664 + }, + { + "step": 70, + "lr": 3.5000000000000004e-05, + "sup_loss": 2.004195702224374 + }, + { + "step": 71, + "lr": 3.55e-05, + "sup_loss": 1.9922717092146127 + }, + { + "step": 72, + "lr": 3.6e-05, + "sup_loss": 1.97546507270582 + }, + { + "step": 73, + "lr": 3.65e-05, + "sup_loss": 1.960182337896599 + }, + { + "step": 74, + "lr": 3.7000000000000005e-05, + "sup_loss": 1.9617315183181 + }, + { + "step": 75, + "lr": 3.7500000000000003e-05, + "sup_loss": 1.961098848528872 + }, + { + "step": 76, + "lr": 3.8e-05, + "sup_loss": 1.943396801656729 + }, + { + "step": 77, + "lr": 3.85e-05, + "sup_loss": 1.9379228284285501 + }, + { + "step": 78, + "lr": 3.9e-05, + "sup_loss": 1.9422939315838272 + }, + { + "step": 79, + "lr": 3.9500000000000005e-05, + "sup_loss": 1.933639374366441 + }, + { + "step": 80, + "lr": 4e-05, + "sup_loss": 1.9194373470910142 + }, + { + "step": 81, + "lr": 4.0499999999999995e-05, + "sup_loss": 1.9106562939134015 + }, + { + "step": 82, + "lr": 4.1e-05, + "sup_loss": 1.8834361065300573 + }, + { + "step": 83, + "lr": 4.15e-05, + "sup_loss": 1.8928524633986752 + }, + { + "step": 84, + "lr": 4.2000000000000004e-05, + "sup_loss": 1.8907009072972123 + }, + { + "step": 85, + "lr": 4.25e-05, + "sup_loss": 1.8737958365290759 + }, + { + "step": 86, + "lr": 4.3e-05, + "sup_loss": 1.8552463666904502 + }, + { + "step": 87, + "lr": 4.350000000000001e-05, + "sup_loss": 1.8610634932528922 + }, + { + "step": 88, + "lr": 4.4000000000000006e-05, + "sup_loss": 1.8726442477793834 + }, + { + "step": 89, + "lr": 4.45e-05, + "sup_loss": 1.850989213349782 + }, + { + "step": 90, + "lr": 4.5e-05, + "sup_loss": 1.8364123661818825 + }, + { + "step": 91, + "lr": 4.55e-05, + "sup_loss": 1.8378995686718504 + }, + { + "step": 92, + "lr": 4.6e-05, + "sup_loss": 1.8212552337449657 + }, + { + "step": 93, + "lr": 4.6500000000000005e-05, + "sup_loss": 1.8123856149451596 + }, + { + "step": 94, + "lr": 4.7000000000000004e-05, + "sup_loss": 1.8244577364592562 + }, + { + "step": 95, + "lr": 4.7499999999999996e-05, + "sup_loss": 1.8097464716660854 + }, + { + "step": 96, + "lr": 4.8e-05, + "sup_loss": 1.8091811736013546 + }, + { + "step": 97, + "lr": 4.85e-05, + "sup_loss": 1.7978660925661378 + }, + { + "step": 98, + "lr": 4.9e-05, + "sup_loss": 1.8035262566864094 + }, + { + "step": 99, + "lr": 4.9500000000000004e-05, + "sup_loss": 1.7838572069451848 + }, + { + "step": 100, + "lr": 5e-05, + "sup_loss": 1.765573612709, + "lyap1_mean": -6.645934104919434, + "lyap1_max": -6.629775524139404, + "lyap_spec_mean": [ + -6.645934104919434, + -6.647939682006836 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 101, + "lr": 5.050000000000001e-05, + "sup_loss": 1.7718292123582209 + }, + { + "step": 102, + "lr": 5.1000000000000006e-05, + "sup_loss": 1.769429620156411 + }, + { + "step": 103, + "lr": 5.15e-05, + "sup_loss": 1.7761541532021423 + }, + { + "step": 104, + "lr": 5.2000000000000004e-05, + "sup_loss": 1.7557021065122689 + }, + { + "step": 105, + "lr": 5.25e-05, + "sup_loss": 1.753522430314226 + }, + { + "step": 106, + "lr": 5.3e-05, + "sup_loss": 1.7449709258162907 + }, + { + "step": 107, + "lr": 5.3500000000000006e-05, + "sup_loss": 1.7406835412211987 + }, + { + "step": 108, + "lr": 5.4000000000000005e-05, + "sup_loss": 1.7392730822746327 + }, + { + "step": 109, + "lr": 5.4499999999999997e-05, + "sup_loss": 1.714261023587064 + }, + { + "step": 110, + "lr": 5.500000000000001e-05, + "sup_loss": 1.7228040943129044 + }, + { + "step": 111, + "lr": 5.55e-05, + "sup_loss": 1.713869433114336 + }, + { + "step": 112, + "lr": 5.6e-05, + "sup_loss": 1.7400222199535633 + }, + { + "step": 113, + "lr": 5.6500000000000005e-05, + "sup_loss": 1.7196513559501116 + }, + { + "step": 114, + "lr": 5.7e-05, + "sup_loss": 1.7139161832678387 + }, + { + "step": 115, + "lr": 5.75e-05, + "sup_loss": 1.6685873901751527 + }, + { + "step": 116, + "lr": 5.800000000000001e-05, + "sup_loss": 1.6906523084999094 + }, + { + "step": 117, + "lr": 5.85e-05, + "sup_loss": 1.7144940216860909 + }, + { + "step": 118, + "lr": 5.9e-05, + "sup_loss": 1.691214392504199 + }, + { + "step": 119, + "lr": 5.95e-05, + "sup_loss": 1.6684485982436852 + }, + { + "step": 120, + "lr": 6e-05, + "sup_loss": 1.6762212844060034 + }, + { + "step": 121, + "lr": 6.050000000000001e-05, + "sup_loss": 1.690185344754696 + }, + { + "step": 122, + "lr": 6.1000000000000005e-05, + "sup_loss": 1.6975748985069121 + }, + { + "step": 123, + "lr": 6.15e-05, + "sup_loss": 1.6919530875603126 + }, + { + "step": 124, + "lr": 6.2e-05, + "sup_loss": 1.6901255229489793 + }, + { + "step": 125, + "lr": 6.25e-05, + "sup_loss": 1.6840904073211553 + }, + { + "step": 126, + "lr": 6.3e-05, + "sup_loss": 1.6630555519917176 + }, + { + "step": 127, + "lr": 6.350000000000001e-05, + "sup_loss": 1.6489561237615573 + }, + { + "step": 128, + "lr": 6.4e-05, + "sup_loss": 1.6580297586433415 + }, + { + "step": 129, + "lr": 6.45e-05, + "sup_loss": 1.6427564358402926 + }, + { + "step": 130, + "lr": 6.500000000000001e-05, + "sup_loss": 1.6278183600917866 + }, + { + "step": 131, + "lr": 6.55e-05, + "sup_loss": 1.6517253500466267 + }, + { + "step": 132, + "lr": 6.6e-05, + "sup_loss": 1.642541918937894 + }, + { + "step": 133, + "lr": 6.65e-05, + "sup_loss": 1.6741262579367695 + }, + { + "step": 134, + "lr": 6.7e-05, + "sup_loss": 1.6500508583749833 + }, + { + "step": 135, + "lr": 6.75e-05, + "sup_loss": 1.664009166849713 + }, + { + "step": 136, + "lr": 6.8e-05, + "sup_loss": 1.679325086824157 + }, + { + "step": 137, + "lr": 6.85e-05, + "sup_loss": 1.6595201772880044 + }, + { + "step": 138, + "lr": 6.900000000000001e-05, + "sup_loss": 1.6545919591600673 + }, + { + "step": 139, + "lr": 6.950000000000001e-05, + "sup_loss": 1.63273531828923 + }, + { + "step": 140, + "lr": 7.000000000000001e-05, + "sup_loss": 1.6542915070866298 + }, + { + "step": 141, + "lr": 7.05e-05, + "sup_loss": 1.6823128764175808 + }, + { + "step": 142, + "lr": 7.1e-05, + "sup_loss": 1.6355818925673775 + }, + { + "step": 143, + "lr": 7.15e-05, + "sup_loss": 1.619038028521917 + }, + { + "step": 144, + "lr": 7.2e-05, + "sup_loss": 1.6702294066959542 + }, + { + "step": 145, + "lr": 7.25e-05, + "sup_loss": 1.6191061524743915 + }, + { + "step": 146, + "lr": 7.3e-05, + "sup_loss": 1.6462805192394308 + }, + { + "step": 147, + "lr": 7.350000000000001e-05, + "sup_loss": 1.6383527155615467 + }, + { + "step": 148, + "lr": 7.400000000000001e-05, + "sup_loss": 1.5680034185298657 + }, + { + "step": 149, + "lr": 7.45e-05, + "sup_loss": 1.599579545671956 + }, + { + "step": 150, + "lr": 7.500000000000001e-05, + "sup_loss": 1.6107381043908648, + "lyap1_mean": -6.680443286895752, + "lyap1_max": -6.667646408081055, + "lyap_spec_mean": [ + -6.680443286895752, + -6.679490089416504 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 151, + "lr": 7.55e-05, + "sup_loss": 1.6331943361444723 + }, + { + "step": 152, + "lr": 7.6e-05, + "sup_loss": 1.6186159446667354 + }, + { + "step": 153, + "lr": 7.65e-05, + "sup_loss": 1.5932738298918827 + }, + { + "step": 154, + "lr": 7.7e-05, + "sup_loss": 1.634134278191433 + }, + { + "step": 155, + "lr": 7.75e-05, + "sup_loss": 1.622729318115855 + }, + { + "step": 156, + "lr": 7.8e-05, + "sup_loss": 1.6343562972433312 + }, + { + "step": 157, + "lr": 7.850000000000001e-05, + "sup_loss": 1.6019808938889186 + }, + { + "step": 158, + "lr": 7.900000000000001e-05, + "sup_loss": 1.603522979171088 + }, + { + "step": 159, + "lr": 7.950000000000001e-05, + "sup_loss": 1.6363473474570325 + }, + { + "step": 160, + "lr": 8e-05, + "sup_loss": 1.626051532683992 + }, + { + "step": 161, + "lr": 8.05e-05, + "sup_loss": 1.5572688308525355 + }, + { + "step": 162, + "lr": 8.099999999999999e-05, + "sup_loss": 1.5986040847940421 + }, + { + "step": 163, + "lr": 8.150000000000002e-05, + "sup_loss": 1.603001444161075 + }, + { + "step": 164, + "lr": 8.2e-05, + "sup_loss": 1.5680708701938013 + }, + { + "step": 165, + "lr": 8.25e-05, + "sup_loss": 1.591887953679735 + }, + { + "step": 166, + "lr": 8.3e-05, + "sup_loss": 1.597447414563637 + }, + { + "step": 167, + "lr": 8.35e-05, + "sup_loss": 1.570439822396015 + }, + { + "step": 168, + "lr": 8.400000000000001e-05, + "sup_loss": 1.619639569777274 + }, + { + "step": 169, + "lr": 8.450000000000001e-05, + "sup_loss": 1.5742025152753893 + }, + { + "step": 170, + "lr": 8.5e-05, + "sup_loss": 1.5920516144406869 + }, + { + "step": 171, + "lr": 8.55e-05, + "sup_loss": 1.590451636793067 + }, + { + "step": 172, + "lr": 8.6e-05, + "sup_loss": 1.5892578802898323 + }, + { + "step": 173, + "lr": 8.65e-05, + "sup_loss": 1.5723286605739668 + }, + { + "step": 174, + "lr": 8.700000000000001e-05, + "sup_loss": 1.5650768664153798 + }, + { + "step": 175, + "lr": 8.750000000000001e-05, + "sup_loss": 1.5641350770345277 + }, + { + "step": 176, + "lr": 8.800000000000001e-05, + "sup_loss": 1.5718087293880798 + }, + { + "step": 177, + "lr": 8.85e-05, + "sup_loss": 1.5721301108609709 + }, + { + "step": 178, + "lr": 8.9e-05, + "sup_loss": 1.5767578138300593 + }, + { + "step": 179, + "lr": 8.95e-05, + "sup_loss": 1.5962674555438876 + }, + { + "step": 180, + "lr": 9e-05, + "sup_loss": 1.5748646924170986 + }, + { + "step": 181, + "lr": 9.05e-05, + "sup_loss": 1.542304370712881 + }, + { + "step": 182, + "lr": 9.1e-05, + "sup_loss": 1.5795521123482055 + }, + { + "step": 183, + "lr": 9.15e-05, + "sup_loss": 1.5756055688798924 + }, + { + "step": 184, + "lr": 9.2e-05, + "sup_loss": 1.5636117185517475 + }, + { + "step": 185, + "lr": 9.250000000000001e-05, + "sup_loss": 1.5521299906273722 + }, + { + "step": 186, + "lr": 9.300000000000001e-05, + "sup_loss": 1.5249520877796907 + }, + { + "step": 187, + "lr": 9.350000000000001e-05, + "sup_loss": 1.567615583985836 + }, + { + "step": 188, + "lr": 9.400000000000001e-05, + "sup_loss": 1.5446897807231654 + }, + { + "step": 189, + "lr": 9.45e-05, + "sup_loss": 1.58593493753458 + }, + { + "step": 190, + "lr": 9.499999999999999e-05, + "sup_loss": 1.5590768697036184 + }, + { + "step": 191, + "lr": 9.550000000000002e-05, + "sup_loss": 1.5738989490910151 + }, + { + "step": 192, + "lr": 9.6e-05, + "sup_loss": 1.6060686251789913 + }, + { + "step": 193, + "lr": 9.65e-05, + "sup_loss": 1.5595447834098037 + }, + { + "step": 194, + "lr": 9.7e-05, + "sup_loss": 1.5807995257589502 + }, + { + "step": 195, + "lr": 9.75e-05, + "sup_loss": 1.5895042670753294 + }, + { + "step": 196, + "lr": 9.8e-05, + "sup_loss": 1.5759125863427577 + }, + { + "step": 197, + "lr": 9.850000000000001e-05, + "sup_loss": 1.5592385905945854 + }, + { + "step": 198, + "lr": 9.900000000000001e-05, + "sup_loss": 1.5639919986110766 + }, + { + "step": 199, + "lr": 9.95e-05, + "sup_loss": 1.580161702594515 + }, + { + "step": 200, + "lr": 0.0001, + "sup_loss": 1.5477458694954944, + "lyap1_mean": -6.6868791580200195, + "lyap1_max": -6.654043197631836, + "lyap_spec_mean": [ + -6.6868791580200195, + -6.687141418457031 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 201, + "lr": 0.0001, + "sup_loss": 1.5723668194450264 + }, + { + "step": 202, + "lr": 0.0001, + "sup_loss": 1.564699514409567 + }, + { + "step": 203, + "lr": 0.0001, + "sup_loss": 1.5604428029308708 + }, + { + "step": 204, + "lr": 0.0001, + "sup_loss": 1.5861776721359018 + }, + { + "step": 205, + "lr": 0.0001, + "sup_loss": 1.5782700080930012 + }, + { + "step": 206, + "lr": 0.0001, + "sup_loss": 1.5520980953107555 + }, + { + "step": 207, + "lr": 0.0001, + "sup_loss": 1.558527482520001 + }, + { + "step": 208, + "lr": 0.0001, + "sup_loss": 1.5830556008576437 + }, + { + "step": 209, + "lr": 0.0001, + "sup_loss": 1.56305622089171 + }, + { + "step": 210, + "lr": 0.0001, + "sup_loss": 1.5714398581531885 + }, + { + "step": 211, + "lr": 0.0001, + "sup_loss": 1.529996003908584 + }, + { + "step": 212, + "lr": 0.0001, + "sup_loss": 1.5587963770169526 + }, + { + "step": 213, + "lr": 0.0001, + "sup_loss": 1.5629355573124428 + }, + { + "step": 214, + "lr": 0.0001, + "sup_loss": 1.5662224576257553 + }, + { + "step": 215, + "lr": 0.0001, + "sup_loss": 1.5407444113099638 + }, + { + "step": 216, + "lr": 0.0001, + "sup_loss": 1.584385505016842 + }, + { + "step": 217, + "lr": 0.0001, + "sup_loss": 1.5656855026823495 + }, + { + "step": 218, + "lr": 0.0001, + "sup_loss": 1.5463318649792894 + }, + { + "step": 219, + "lr": 0.0001, + "sup_loss": 1.558034354842874 + }, + { + "step": 220, + "lr": 0.0001, + "sup_loss": 1.5842701040177278 + }, + { + "step": 221, + "lr": 0.0001, + "sup_loss": 1.51059326690561 + }, + { + "step": 222, + "lr": 0.0001, + "sup_loss": 1.5525216998009261 + }, + { + "step": 223, + "lr": 0.0001, + "sup_loss": 1.5482722635197943 + }, + { + "step": 224, + "lr": 0.0001, + "sup_loss": 1.4838554858912665 + }, + { + "step": 225, + "lr": 0.0001, + "sup_loss": 1.566661886621028 + }, + { + "step": 226, + "lr": 0.0001, + "sup_loss": 1.5400955015597735 + }, + { + "step": 227, + "lr": 0.0001, + "sup_loss": 1.5687526858500491 + }, + { + "step": 228, + "lr": 0.0001, + "sup_loss": 1.5691507976198855 + }, + { + "step": 229, + "lr": 0.0001, + "sup_loss": 1.53198097838484 + }, + { + "step": 230, + "lr": 0.0001, + "sup_loss": 1.5148413488005252 + }, + { + "step": 231, + "lr": 0.0001, + "sup_loss": 1.5493080655522284 + }, + { + "step": 232, + "lr": 0.0001, + "sup_loss": 1.5442163396736155 + }, + { + "step": 233, + "lr": 0.0001, + "sup_loss": 1.54046977806173 + }, + { + "step": 234, + "lr": 0.0001, + "sup_loss": 1.5425880946086366 + }, + { + "step": 235, + "lr": 0.0001, + "sup_loss": 1.575076912686921 + }, + { + "step": 236, + "lr": 0.0001, + "sup_loss": 1.5428485905649254 + }, + { + "step": 237, + "lr": 0.0001, + "sup_loss": 1.5395443580469992 + }, + { + "step": 238, + "lr": 0.0001, + "sup_loss": 1.5883071635836998 + }, + { + "step": 239, + "lr": 0.0001, + "sup_loss": 1.534849519729787 + }, + { + "step": 240, + "lr": 0.0001, + "sup_loss": 1.5710274969168985 + }, + { + "step": 241, + "lr": 0.0001, + "sup_loss": 1.5784896160961035 + }, + { + "step": 242, + "lr": 0.0001, + "sup_loss": 1.537032529248547 + }, + { + "step": 243, + "lr": 0.0001, + "sup_loss": 1.5410510463366764 + }, + { + "step": 244, + "lr": 0.0001, + "sup_loss": 1.567677100071934 + }, + { + "step": 245, + "lr": 0.0001, + "sup_loss": 1.5256795166825063 + }, + { + "step": 246, + "lr": 0.0001, + "sup_loss": 1.5455988643443055 + }, + { + "step": 247, + "lr": 0.0001, + "sup_loss": 1.5324020729077692 + }, + { + "step": 248, + "lr": 0.0001, + "sup_loss": 1.5249119581282295 + }, + { + "step": 249, + "lr": 0.0001, + "sup_loss": 1.5124648889243315 + }, + { + "step": 250, + "lr": 0.0001, + "sup_loss": 1.5978004357536462, + "lyap1_mean": -6.694179534912109, + "lyap1_max": -6.644731521606445, + "lyap_spec_mean": [ + -6.694179534912109, + -6.69418478012085 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 251, + "lr": 0.0001, + "sup_loss": 1.5384092154284206 + }, + { + "step": 252, + "lr": 0.0001, + "sup_loss": 1.5343629147099467 + }, + { + "step": 253, + "lr": 0.0001, + "sup_loss": 1.5566998256192501 + }, + { + "step": 254, + "lr": 0.0001, + "sup_loss": 1.527463187647169 + }, + { + "step": 255, + "lr": 0.0001, + "sup_loss": 1.5466020877298672 + }, + { + "step": 256, + "lr": 0.0001, + "sup_loss": 1.5252548207327843 + }, + { + "step": 257, + "lr": 0.0001, + "sup_loss": 1.5328926705773882 + }, + { + "step": 258, + "lr": 0.0001, + "sup_loss": 1.5257264021083035 + }, + { + "step": 259, + "lr": 0.0001, + "sup_loss": 1.5482693336878994 + }, + { + "step": 260, + "lr": 0.0001, + "sup_loss": 1.5246880613977345 + }, + { + "step": 261, + "lr": 0.0001, + "sup_loss": 1.5368057639664512 + }, + { + "step": 262, + "lr": 0.0001, + "sup_loss": 1.520905230766904 + }, + { + "step": 263, + "lr": 0.0001, + "sup_loss": 1.5415538284759558 + }, + { + "step": 264, + "lr": 0.0001, + "sup_loss": 1.5264283512779455 + }, + { + "step": 265, + "lr": 0.0001, + "sup_loss": 1.5484230592639259 + }, + { + "step": 266, + "lr": 0.0001, + "sup_loss": 1.5003885457020067 + }, + { + "step": 267, + "lr": 0.0001, + "sup_loss": 1.556837774591551 + }, + { + "step": 268, + "lr": 0.0001, + "sup_loss": 1.5553436077656102 + }, + { + "step": 269, + "lr": 0.0001, + "sup_loss": 1.5453542722634106 + }, + { + "step": 270, + "lr": 0.0001, + "sup_loss": 1.5652166192745618 + }, + { + "step": 271, + "lr": 0.0001, + "sup_loss": 1.5215748778019837 + }, + { + "step": 272, + "lr": 0.0001, + "sup_loss": 1.5438651864196689 + }, + { + "step": 273, + "lr": 0.0001, + "sup_loss": 1.5408136797939596 + }, + { + "step": 274, + "lr": 0.0001, + "sup_loss": 1.5026193032525657 + }, + { + "step": 275, + "lr": 0.0001, + "sup_loss": 1.5477253397291126 + }, + { + "step": 276, + "lr": 0.0001, + "sup_loss": 1.5336627827427467 + }, + { + "step": 277, + "lr": 0.0001, + "sup_loss": 1.5270861895780656 + }, + { + "step": 278, + "lr": 0.0001, + "sup_loss": 1.518488015782166 + }, + { + "step": 279, + "lr": 0.0001, + "sup_loss": 1.5134708507259873 + }, + { + "step": 280, + "lr": 0.0001, + "sup_loss": 1.5431403123968697 + }, + { + "step": 281, + "lr": 0.0001, + "sup_loss": 1.541801403650025 + }, + { + "step": 282, + "lr": 0.0001, + "sup_loss": 1.519480337561989 + }, + { + "step": 283, + "lr": 0.0001, + "sup_loss": 1.5299565131627453 + }, + { + "step": 284, + "lr": 0.0001, + "sup_loss": 1.547917587276493 + }, + { + "step": 285, + "lr": 0.0001, + "sup_loss": 1.4938832063120242 + }, + { + "step": 286, + "lr": 0.0001, + "sup_loss": 1.525396268292315 + }, + { + "step": 287, + "lr": 0.0001, + "sup_loss": 1.541475554162341 + }, + { + "step": 288, + "lr": 0.0001, + "sup_loss": 1.5072059477977395 + }, + { + "step": 289, + "lr": 0.0001, + "sup_loss": 1.5456634379236454 + }, + { + "step": 290, + "lr": 0.0001, + "sup_loss": 1.5283500594160828 + }, + { + "step": 291, + "lr": 0.0001, + "sup_loss": 1.5115168973991229 + }, + { + "step": 292, + "lr": 0.0001, + "sup_loss": 1.5210975319461015 + }, + { + "step": 293, + "lr": 0.0001, + "sup_loss": 1.5147547171891933 + }, + { + "step": 294, + "lr": 0.0001, + "sup_loss": 1.540661142483917 + }, + { + "step": 295, + "lr": 0.0001, + "sup_loss": 1.5180601465535941 + }, + { + "step": 296, + "lr": 0.0001, + "sup_loss": 1.5469400636944477 + }, + { + "step": 297, + "lr": 0.0001, + "sup_loss": 1.5209362658980428 + }, + { + "step": 298, + "lr": 0.0001, + "sup_loss": 1.5442122135802556 + }, + { + "step": 299, + "lr": 0.0001, + "sup_loss": 1.5299168861048704 + }, + { + "step": 300, + "lr": 0.0001, + "sup_loss": 1.5367603794149578, + "lyap1_mean": -6.731600761413574, + "lyap1_max": -6.705668926239014, + "lyap_spec_mean": [ + -6.731600761413574, + -6.729957103729248 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 301, + "lr": 0.0001, + "sup_loss": 1.5267677902729708 + }, + { + "step": 302, + "lr": 0.0001, + "sup_loss": 1.5490004131566173 + }, + { + "step": 303, + "lr": 0.0001, + "sup_loss": 1.5324941437266195 + }, + { + "step": 304, + "lr": 0.0001, + "sup_loss": 1.5190387495269355 + }, + { + "step": 305, + "lr": 0.0001, + "sup_loss": 1.509078282908147 + }, + { + "step": 306, + "lr": 0.0001, + "sup_loss": 1.5385538534217427 + }, + { + "step": 307, + "lr": 0.0001, + "sup_loss": 1.5221630289120884 + }, + { + "step": 308, + "lr": 0.0001, + "sup_loss": 1.531880840558637 + }, + { + "step": 309, + "lr": 0.0001, + "sup_loss": 1.5322693013837414 + }, + { + "step": 310, + "lr": 0.0001, + "sup_loss": 1.5456882921503572 + }, + { + "step": 311, + "lr": 0.0001, + "sup_loss": 1.5482640300985837 + }, + { + "step": 312, + "lr": 0.0001, + "sup_loss": 1.4953605908689824 + }, + { + "step": 313, + "lr": 0.0001, + "sup_loss": 1.504275592869123 + }, + { + "step": 314, + "lr": 0.0001, + "sup_loss": 1.5314498158594896 + }, + { + "step": 315, + "lr": 0.0001, + "sup_loss": 1.5487909165979727 + }, + { + "step": 316, + "lr": 0.0001, + "sup_loss": 1.5354934367073998 + }, + { + "step": 317, + "lr": 0.0001, + "sup_loss": 1.5613511901676795 + }, + { + "step": 318, + "lr": 0.0001, + "sup_loss": 1.5212551833796315 + }, + { + "step": 319, + "lr": 0.0001, + "sup_loss": 1.5354066475975543 + }, + { + "step": 320, + "lr": 0.0001, + "sup_loss": 1.513892551706198 + }, + { + "step": 321, + "lr": 0.0001, + "sup_loss": 1.5247447921083763 + }, + { + "step": 322, + "lr": 0.0001, + "sup_loss": 1.5663392109423493 + }, + { + "step": 323, + "lr": 0.0001, + "sup_loss": 1.5469443724563157 + }, + { + "step": 324, + "lr": 0.0001, + "sup_loss": 1.5241835576596356 + }, + { + "step": 325, + "lr": 0.0001, + "sup_loss": 1.56112866420628 + }, + { + "step": 326, + "lr": 0.0001, + "sup_loss": 1.514327623223098 + }, + { + "step": 327, + "lr": 0.0001, + "sup_loss": 1.5357172586130452 + }, + { + "step": 328, + "lr": 0.0001, + "sup_loss": 1.52557571995858 + }, + { + "step": 329, + "lr": 0.0001, + "sup_loss": 1.5063130482506772 + }, + { + "step": 330, + "lr": 0.0001, + "sup_loss": 1.510772981261169 + }, + { + "step": 331, + "lr": 0.0001, + "sup_loss": 1.525386254408428 + }, + { + "step": 332, + "lr": 0.0001, + "sup_loss": 1.5372994463442498 + }, + { + "step": 333, + "lr": 0.0001, + "sup_loss": 1.4956818160326795 + }, + { + "step": 334, + "lr": 0.0001, + "sup_loss": 1.5172208481119904 + }, + { + "step": 335, + "lr": 0.0001, + "sup_loss": 1.5278558278741006 + }, + { + "step": 336, + "lr": 0.0001, + "sup_loss": 1.5067972329936372 + }, + { + "step": 337, + "lr": 0.0001, + "sup_loss": 1.5190452238016992 + }, + { + "step": 338, + "lr": 0.0001, + "sup_loss": 1.5084175022670525 + }, + { + "step": 339, + "lr": 0.0001, + "sup_loss": 1.525797596254893 + }, + { + "step": 340, + "lr": 0.0001, + "sup_loss": 1.5319172302493027 + }, + { + "step": 341, + "lr": 0.0001, + "sup_loss": 1.538821554040033 + }, + { + "step": 342, + "lr": 0.0001, + "sup_loss": 1.5317685528260372 + }, + { + "step": 343, + "lr": 0.0001, + "sup_loss": 1.4926112633097048 + }, + { + "step": 344, + "lr": 0.0001, + "sup_loss": 1.5147849643214368 + }, + { + "step": 345, + "lr": 0.0001, + "sup_loss": 1.547711727370116 + }, + { + "step": 346, + "lr": 0.0001, + "sup_loss": 1.515529849808384 + }, + { + "step": 347, + "lr": 0.0001, + "sup_loss": 1.5049246647550845 + }, + { + "step": 348, + "lr": 0.0001, + "sup_loss": 1.501525262570652 + }, + { + "step": 349, + "lr": 0.0001, + "sup_loss": 1.49081882244944 + }, + { + "step": 350, + "lr": 0.0001, + "sup_loss": 1.5288388316196229, + "lyap1_mean": -6.768826484680176, + "lyap1_max": -6.735835075378418, + "lyap_spec_mean": [ + -6.768826484680176, + -6.769077777862549 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 351, + "lr": 0.0001, + "sup_loss": 1.5415546296312443 + }, + { + "step": 352, + "lr": 0.0001, + "sup_loss": 1.4937428007082285 + }, + { + "step": 353, + "lr": 0.0001, + "sup_loss": 1.5377792072256968 + }, + { + "step": 354, + "lr": 0.0001, + "sup_loss": 1.5407405719391567 + }, + { + "step": 355, + "lr": 0.0001, + "sup_loss": 1.5367920979990177 + }, + { + "step": 356, + "lr": 0.0001, + "sup_loss": 1.5307866517061364 + }, + { + "step": 357, + "lr": 0.0001, + "sup_loss": 1.5383308453236424 + }, + { + "step": 358, + "lr": 0.0001, + "sup_loss": 1.4966814733345377 + }, + { + "step": 359, + "lr": 0.0001, + "sup_loss": 1.5222646538877784 + }, + { + "step": 360, + "lr": 0.0001, + "sup_loss": 1.5257339137152008 + }, + { + "step": 361, + "lr": 0.0001, + "sup_loss": 1.5164813046994263 + }, + { + "step": 362, + "lr": 0.0001, + "sup_loss": 1.5275411407536763 + }, + { + "step": 363, + "lr": 0.0001, + "sup_loss": 1.530546309389911 + }, + { + "step": 364, + "lr": 0.0001, + "sup_loss": 1.5231208048578198 + }, + { + "step": 365, + "lr": 0.0001, + "sup_loss": 1.516284883637423 + }, + { + "step": 366, + "lr": 0.0001, + "sup_loss": 1.4956760481170648 + }, + { + "step": 367, + "lr": 0.0001, + "sup_loss": 1.5348023348014486 + }, + { + "step": 368, + "lr": 0.0001, + "sup_loss": 1.5469043091619528 + }, + { + "step": 369, + "lr": 0.0001, + "sup_loss": 1.508701474439553 + }, + { + "step": 370, + "lr": 0.0001, + "sup_loss": 1.5035497253083892 + }, + { + "step": 371, + "lr": 0.0001, + "sup_loss": 1.50805146455965 + }, + { + "step": 372, + "lr": 0.0001, + "sup_loss": 1.5235418304604582 + }, + { + "step": 373, + "lr": 0.0001, + "sup_loss": 1.5051946201321436 + }, + { + "step": 374, + "lr": 0.0001, + "sup_loss": 1.5760435357157099 + }, + { + "step": 375, + "lr": 0.0001, + "sup_loss": 1.5358853569822477 + }, + { + "step": 376, + "lr": 0.0001, + "sup_loss": 1.4922115545345278 + }, + { + "step": 377, + "lr": 0.0001, + "sup_loss": 1.5195063290024502 + }, + { + "step": 378, + "lr": 0.0001, + "sup_loss": 1.5025468941472218 + }, + { + "step": 379, + "lr": 0.0001, + "sup_loss": 1.5147771276300177 + }, + { + "step": 380, + "lr": 0.0001, + "sup_loss": 1.5896931221452932 + }, + { + "step": 381, + "lr": 0.0001, + "sup_loss": 1.4996664797783066 + }, + { + "step": 382, + "lr": 0.0001, + "sup_loss": 1.5329751270993626 + }, + { + "step": 383, + "lr": 0.0001, + "sup_loss": 1.4888887510594488 + }, + { + "step": 384, + "lr": 0.0001, + "sup_loss": 1.5017783762237125 + }, + { + "step": 385, + "lr": 0.0001, + "sup_loss": 1.4954119391046687 + }, + { + "step": 386, + "lr": 0.0001, + "sup_loss": 1.5197900278040006 + }, + { + "step": 387, + "lr": 0.0001, + "sup_loss": 1.5426613533741342 + }, + { + "step": 388, + "lr": 0.0001, + "sup_loss": 1.5429999638477723 + }, + { + "step": 389, + "lr": 0.0001, + "sup_loss": 1.532546033613357 + }, + { + "step": 390, + "lr": 0.0001, + "sup_loss": 1.4919258952284065 + }, + { + "step": 391, + "lr": 0.0001, + "sup_loss": 1.5219337390273724 + }, + { + "step": 392, + "lr": 0.0001, + "sup_loss": 1.5478330957124837 + }, + { + "step": 393, + "lr": 0.0001, + "sup_loss": 1.5359589244340948 + }, + { + "step": 394, + "lr": 0.0001, + "sup_loss": 1.5412368161721592 + }, + { + "step": 395, + "lr": 0.0001, + "sup_loss": 1.5205820683421143 + }, + { + "step": 396, + "lr": 0.0001, + "sup_loss": 1.5159798976856904 + }, + { + "step": 397, + "lr": 0.0001, + "sup_loss": 1.4777741617731257 + }, + { + "step": 398, + "lr": 0.0001, + "sup_loss": 1.5215005801879995 + }, + { + "step": 399, + "lr": 0.0001, + "sup_loss": 1.5079616952732788 + }, + { + "step": 400, + "lr": 0.0001, + "sup_loss": 1.495910037773762, + "lyap1_mean": -6.776495933532715, + "lyap1_max": -6.758118629455566, + "lyap_spec_mean": [ + -6.776495933532715, + -6.777163982391357 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 401, + "lr": 0.0001, + "sup_loss": 1.5217005574706701 + }, + { + "step": 402, + "lr": 0.0001, + "sup_loss": 1.535998508545498 + }, + { + "step": 403, + "lr": 0.0001, + "sup_loss": 1.4938829571330041 + }, + { + "step": 404, + "lr": 0.0001, + "sup_loss": 1.5042338652329252 + }, + { + "step": 405, + "lr": 0.0001, + "sup_loss": 1.538283850584171 + }, + { + "step": 406, + "lr": 0.0001, + "sup_loss": 1.5170335668757478 + }, + { + "step": 407, + "lr": 0.0001, + "sup_loss": 1.5043685155341067 + }, + { + "step": 408, + "lr": 0.0001, + "sup_loss": 1.5252170557965918 + }, + { + "step": 409, + "lr": 0.0001, + "sup_loss": 1.5543400645748704 + }, + { + "step": 410, + "lr": 0.0001, + "sup_loss": 1.518284223363948 + }, + { + "step": 411, + "lr": 0.0001, + "sup_loss": 1.530843710395433 + }, + { + "step": 412, + "lr": 0.0001, + "sup_loss": 1.523526609751549 + }, + { + "step": 413, + "lr": 0.0001, + "sup_loss": 1.5347577761597417 + }, + { + "step": 414, + "lr": 0.0001, + "sup_loss": 1.5482723268724043 + }, + { + "step": 415, + "lr": 0.0001, + "sup_loss": 1.5106411249861507 + }, + { + "step": 416, + "lr": 0.0001, + "sup_loss": 1.5377137499597227 + }, + { + "step": 417, + "lr": 0.0001, + "sup_loss": 1.5470692533854244 + }, + { + "step": 418, + "lr": 0.0001, + "sup_loss": 1.530579133413735 + }, + { + "step": 419, + "lr": 0.0001, + "sup_loss": 1.513712776987345 + }, + { + "step": 420, + "lr": 0.0001, + "sup_loss": 1.5275970838549073 + }, + { + "step": 421, + "lr": 0.0001, + "sup_loss": 1.5065633750579157 + }, + { + "step": 422, + "lr": 0.0001, + "sup_loss": 1.5208309190224893 + }, + { + "step": 423, + "lr": 0.0001, + "sup_loss": 1.4901535565874426 + }, + { + "step": 424, + "lr": 0.0001, + "sup_loss": 1.541493181989591 + }, + { + "step": 425, + "lr": 0.0001, + "sup_loss": 1.5069517474786296 + }, + { + "step": 426, + "lr": 0.0001, + "sup_loss": 1.524255888570083 + }, + { + "step": 427, + "lr": 0.0001, + "sup_loss": 1.509566015485319 + }, + { + "step": 428, + "lr": 0.0001, + "sup_loss": 1.5065644131228995 + }, + { + "step": 429, + "lr": 0.0001, + "sup_loss": 1.5168142824769222 + }, + { + "step": 430, + "lr": 0.0001, + "sup_loss": 1.5094533303891793 + }, + { + "step": 431, + "lr": 0.0001, + "sup_loss": 1.5310067010010535 + }, + { + "step": 432, + "lr": 0.0001, + "sup_loss": 1.4936585680050196 + }, + { + "step": 433, + "lr": 0.0001, + "sup_loss": 1.5170796998766567 + }, + { + "step": 434, + "lr": 0.0001, + "sup_loss": 1.4663801573932203 + }, + { + "step": 435, + "lr": 0.0001, + "sup_loss": 1.5053680594486931 + }, + { + "step": 436, + "lr": 0.0001, + "sup_loss": 1.5028730726827486 + }, + { + "step": 437, + "lr": 0.0001, + "sup_loss": 1.490572772297063 + }, + { + "step": 438, + "lr": 0.0001, + "sup_loss": 1.5032827873330354 + }, + { + "step": 439, + "lr": 0.0001, + "sup_loss": 1.5226119048921678 + }, + { + "step": 440, + "lr": 0.0001, + "sup_loss": 1.5597227382635503 + }, + { + "step": 441, + "lr": 0.0001, + "sup_loss": 1.5237574660485953 + }, + { + "step": 442, + "lr": 0.0001, + "sup_loss": 1.5347296789628524 + }, + { + "step": 443, + "lr": 0.0001, + "sup_loss": 1.5230422566997506 + }, + { + "step": 444, + "lr": 0.0001, + "sup_loss": 1.5491641821715534 + }, + { + "step": 445, + "lr": 0.0001, + "sup_loss": 1.509394757469705 + }, + { + "step": 446, + "lr": 0.0001, + "sup_loss": 1.4962407714481252 + }, + { + "step": 447, + "lr": 0.0001, + "sup_loss": 1.522649675786416 + }, + { + "step": 448, + "lr": 0.0001, + "sup_loss": 1.5226048456225543 + }, + { + "step": 449, + "lr": 0.0001, + "sup_loss": 1.5331250593048695 + }, + { + "step": 450, + "lr": 0.0001, + "sup_loss": 1.515925917849977, + "lyap1_mean": -6.795431137084961, + "lyap1_max": -6.768151760101318, + "lyap_spec_mean": [ + -6.795431137084961, + -6.794274806976318 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 451, + "lr": 0.0001, + "sup_loss": 1.5282498362302581 + }, + { + "step": 452, + "lr": 0.0001, + "sup_loss": 1.5132511622880294 + }, + { + "step": 453, + "lr": 0.0001, + "sup_loss": 1.5061698451036576 + }, + { + "step": 454, + "lr": 0.0001, + "sup_loss": 1.5327067666562653 + }, + { + "step": 455, + "lr": 0.0001, + "sup_loss": 1.5432148891759199 + }, + { + "step": 456, + "lr": 0.0001, + "sup_loss": 1.487606374372353 + }, + { + "step": 457, + "lr": 0.0001, + "sup_loss": 1.5161990353568249 + }, + { + "step": 458, + "lr": 0.0001, + "sup_loss": 1.4965745475211065 + }, + { + "step": 459, + "lr": 0.0001, + "sup_loss": 1.5198828941042917 + }, + { + "step": 460, + "lr": 0.0001, + "sup_loss": 1.5305336263472862 + }, + { + "step": 461, + "lr": 0.0001, + "sup_loss": 1.5149052893451012 + }, + { + "step": 462, + "lr": 0.0001, + "sup_loss": 1.5025796388903865 + }, + { + "step": 463, + "lr": 0.0001, + "sup_loss": 1.5869712464150953 + }, + { + "step": 464, + "lr": 0.0001, + "sup_loss": 1.5057992201875046 + }, + { + "step": 465, + "lr": 0.0001, + "sup_loss": 1.5120564804847023 + }, + { + "step": 466, + "lr": 0.0001, + "sup_loss": 1.5120215616736532 + }, + { + "step": 467, + "lr": 0.0001, + "sup_loss": 1.5091493754340413 + }, + { + "step": 468, + "lr": 0.0001, + "sup_loss": 1.5323652889230723 + }, + { + "step": 469, + "lr": 0.0001, + "sup_loss": 1.5354809126070437 + }, + { + "step": 470, + "lr": 0.0001, + "sup_loss": 1.5160184614151824 + }, + { + "step": 471, + "lr": 0.0001, + "sup_loss": 1.5393198861487136 + }, + { + "step": 472, + "lr": 0.0001, + "sup_loss": 1.5095728851643273 + }, + { + "step": 473, + "lr": 0.0001, + "sup_loss": 1.4950199933108161 + }, + { + "step": 474, + "lr": 0.0001, + "sup_loss": 1.4880223885745154 + }, + { + "step": 475, + "lr": 0.0001, + "sup_loss": 1.5220763223709426 + }, + { + "step": 476, + "lr": 0.0001, + "sup_loss": 1.5291296437464985 + }, + { + "step": 477, + "lr": 0.0001, + "sup_loss": 1.4880739155134965 + }, + { + "step": 478, + "lr": 0.0001, + "sup_loss": 1.5351122331439055 + }, + { + "step": 479, + "lr": 0.0001, + "sup_loss": 1.522225478193996 + }, + { + "step": 480, + "lr": 0.0001, + "sup_loss": 1.53495790560135 + }, + { + "step": 481, + "lr": 0.0001, + "sup_loss": 1.5253319198843884 + }, + { + "step": 482, + "lr": 0.0001, + "sup_loss": 1.54836948093061 + }, + { + "step": 483, + "lr": 0.0001, + "sup_loss": 1.5153069188564097 + }, + { + "step": 484, + "lr": 0.0001, + "sup_loss": 1.5081205638874275 + }, + { + "step": 485, + "lr": 0.0001, + "sup_loss": 1.515517684638477 + }, + { + "step": 486, + "lr": 0.0001, + "sup_loss": 1.548798319957227 + }, + { + "step": 487, + "lr": 0.0001, + "sup_loss": 1.508224619597713 + }, + { + "step": 488, + "lr": 0.0001, + "sup_loss": 1.5081144270667044 + }, + { + "step": 489, + "lr": 0.0001, + "sup_loss": 1.5316173594952238 + }, + { + "step": 490, + "lr": 0.0001, + "sup_loss": 1.5109067315946623 + }, + { + "step": 491, + "lr": 0.0001, + "sup_loss": 1.5217231020214306 + }, + { + "step": 492, + "lr": 0.0001, + "sup_loss": 1.5250587129141693 + }, + { + "step": 493, + "lr": 0.0001, + "sup_loss": 1.4877844106809268 + }, + { + "step": 494, + "lr": 0.0001, + "sup_loss": 1.5344331622723024 + }, + { + "step": 495, + "lr": 0.0001, + "sup_loss": 1.5260100240880243 + }, + { + "step": 496, + "lr": 0.0001, + "sup_loss": 1.500453052131941 + }, + { + "step": 497, + "lr": 0.0001, + "sup_loss": 1.5305699544559332 + }, + { + "step": 498, + "lr": 0.0001, + "sup_loss": 1.5256666107826882 + }, + { + "step": 499, + "lr": 0.0001, + "sup_loss": 1.5013564830363537 + }, + { + "step": 500, + "lr": 0.0001, + "sup_loss": 1.5188585494176774, + "lyap1_mean": -6.791590213775635, + "lyap1_max": -6.772494792938232, + "lyap_spec_mean": [ + -6.791589736938477, + -6.79250431060791 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 501, + "lr": 0.0001, + "sup_loss": 1.5419606241978687 + }, + { + "step": 502, + "lr": 0.0001, + "sup_loss": 1.5421828984991521 + }, + { + "step": 503, + "lr": 0.0001, + "sup_loss": 1.5357003899215982 + }, + { + "step": 504, + "lr": 0.0001, + "sup_loss": 1.530721237113792 + }, + { + "step": 505, + "lr": 0.0001, + "sup_loss": 1.511567722152634 + }, + { + "step": 506, + "lr": 0.0001, + "sup_loss": 1.5323639499719792 + }, + { + "step": 507, + "lr": 0.0001, + "sup_loss": 1.5010858492960906 + }, + { + "step": 508, + "lr": 0.0001, + "sup_loss": 1.515861816104251 + }, + { + "step": 509, + "lr": 0.0001, + "sup_loss": 1.507546999875379 + }, + { + "step": 510, + "lr": 0.0001, + "sup_loss": 1.4473171150456647 + }, + { + "step": 511, + "lr": 0.0001, + "sup_loss": 1.5250415366020011 + }, + { + "step": 512, + "lr": 0.0001, + "sup_loss": 1.5356975150173802 + }, + { + "step": 513, + "lr": 0.0001, + "sup_loss": 1.5144988164026012 + }, + { + "step": 514, + "lr": 0.0001, + "sup_loss": 1.5490970785299154 + }, + { + "step": 515, + "lr": 0.0001, + "sup_loss": 1.496113593839379 + }, + { + "step": 516, + "lr": 0.0001, + "sup_loss": 1.498487162807379 + }, + { + "step": 517, + "lr": 0.0001, + "sup_loss": 1.4981849056946255 + }, + { + "step": 518, + "lr": 0.0001, + "sup_loss": 1.5373433675463626 + }, + { + "step": 519, + "lr": 0.0001, + "sup_loss": 1.4812035208840872 + }, + { + "step": 520, + "lr": 0.0001, + "sup_loss": 1.47771356385523 + }, + { + "step": 521, + "lr": 0.0001, + "sup_loss": 1.5449288085839221 + }, + { + "step": 522, + "lr": 0.0001, + "sup_loss": 1.5070971701758975 + }, + { + "step": 523, + "lr": 0.0001, + "sup_loss": 1.5270652188211973 + }, + { + "step": 524, + "lr": 0.0001, + "sup_loss": 1.5359717697211641 + }, + { + "step": 525, + "lr": 0.0001, + "sup_loss": 1.5163803211806575 + }, + { + "step": 526, + "lr": 0.0001, + "sup_loss": 1.4873522597396416 + }, + { + "step": 527, + "lr": 0.0001, + "sup_loss": 1.4766349808193844 + }, + { + "step": 528, + "lr": 0.0001, + "sup_loss": 1.4398690054531398 + }, + { + "step": 529, + "lr": 0.0001, + "sup_loss": 1.4616981072030113 + }, + { + "step": 530, + "lr": 0.0001, + "sup_loss": 1.5029602902675654 + }, + { + "step": 531, + "lr": 0.0001, + "sup_loss": 1.5234289793130582 + }, + { + "step": 532, + "lr": 0.0001, + "sup_loss": 1.5249104934379372 + }, + { + "step": 533, + "lr": 0.0001, + "sup_loss": 1.4803204314707359 + }, + { + "step": 534, + "lr": 0.0001, + "sup_loss": 1.5328382853747362 + }, + { + "step": 535, + "lr": 0.0001, + "sup_loss": 1.5179482902634496 + }, + { + "step": 536, + "lr": 0.0001, + "sup_loss": 1.5211828598536354 + }, + { + "step": 537, + "lr": 0.0001, + "sup_loss": 1.5274874021689337 + }, + { + "step": 538, + "lr": 0.0001, + "sup_loss": 1.500564786247306 + }, + { + "step": 539, + "lr": 0.0001, + "sup_loss": 1.521037452581265 + }, + { + "step": 540, + "lr": 0.0001, + "sup_loss": 1.538061478112434 + }, + { + "step": 541, + "lr": 0.0001, + "sup_loss": 1.5381210991518974 + }, + { + "step": 542, + "lr": 0.0001, + "sup_loss": 1.5013994631824021 + }, + { + "step": 543, + "lr": 0.0001, + "sup_loss": 1.5654164527576346 + }, + { + "step": 544, + "lr": 0.0001, + "sup_loss": 1.5144121736857774 + }, + { + "step": 545, + "lr": 0.0001, + "sup_loss": 1.5275361742225335 + }, + { + "step": 546, + "lr": 0.0001, + "sup_loss": 1.5246118056555094 + }, + { + "step": 547, + "lr": 0.0001, + "sup_loss": 1.5038810676440577 + }, + { + "step": 548, + "lr": 0.0001, + "sup_loss": 1.4733352301839726 + }, + { + "step": 549, + "lr": 0.0001, + "sup_loss": 1.5239435882358878 + }, + { + "step": 550, + "lr": 0.0001, + "sup_loss": 1.5175359020051566, + "lyap1_mean": -6.765993118286133, + "lyap1_max": -6.736642837524414, + "lyap_spec_mean": [ + -6.765993118286133, + -6.764594554901123 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 551, + "lr": 0.0001, + "sup_loss": 1.4968662422053387 + }, + { + "step": 552, + "lr": 0.0001, + "sup_loss": 1.4896592338924552 + }, + { + "step": 553, + "lr": 0.0001, + "sup_loss": 1.533292957859652 + }, + { + "step": 554, + "lr": 0.0001, + "sup_loss": 1.514270599044644 + }, + { + "step": 555, + "lr": 0.0001, + "sup_loss": 1.5250075259201878 + }, + { + "step": 556, + "lr": 0.0001, + "sup_loss": 1.505292036558018 + }, + { + "step": 557, + "lr": 0.0001, + "sup_loss": 1.5370056435293413 + }, + { + "step": 558, + "lr": 0.0001, + "sup_loss": 1.4656788697742547 + }, + { + "step": 559, + "lr": 0.0001, + "sup_loss": 1.5362274302772925 + }, + { + "step": 560, + "lr": 0.0001, + "sup_loss": 1.5245343080299176 + }, + { + "step": 561, + "lr": 0.0001, + "sup_loss": 1.5081152106879827 + }, + { + "step": 562, + "lr": 0.0001, + "sup_loss": 1.4994066555448664 + }, + { + "step": 563, + "lr": 0.0001, + "sup_loss": 1.5197447553727503 + }, + { + "step": 564, + "lr": 0.0001, + "sup_loss": 1.4796461514181756 + }, + { + "step": 565, + "lr": 0.0001, + "sup_loss": 1.527453622104409 + }, + { + "step": 566, + "lr": 0.0001, + "sup_loss": 1.5211536061599533 + }, + { + "step": 567, + "lr": 0.0001, + "sup_loss": 1.5222198327095844 + }, + { + "step": 568, + "lr": 0.0001, + "sup_loss": 1.5104475006960905 + }, + { + "step": 569, + "lr": 0.0001, + "sup_loss": 1.556950775037779 + }, + { + "step": 570, + "lr": 0.0001, + "sup_loss": 1.489439387709364 + }, + { + "step": 571, + "lr": 0.0001, + "sup_loss": 1.5247285889255449 + }, + { + "step": 572, + "lr": 0.0001, + "sup_loss": 1.520800154045211 + }, + { + "step": 573, + "lr": 0.0001, + "sup_loss": 1.554697797404213 + }, + { + "step": 574, + "lr": 0.0001, + "sup_loss": 1.4829480801351373 + }, + { + "step": 575, + "lr": 0.0001, + "sup_loss": 1.4764715080232702 + }, + { + "step": 576, + "lr": 0.0001, + "sup_loss": 1.5269003596506046 + }, + { + "step": 577, + "lr": 0.0001, + "sup_loss": 1.5191089025254334 + }, + { + "step": 578, + "lr": 0.0001, + "sup_loss": 1.4969294335143073 + }, + { + "step": 579, + "lr": 0.0001, + "sup_loss": 1.5173509812616253 + }, + { + "step": 580, + "lr": 0.0001, + "sup_loss": 1.5670732878743052 + }, + { + "step": 581, + "lr": 0.0001, + "sup_loss": 1.5069296991136054 + }, + { + "step": 582, + "lr": 0.0001, + "sup_loss": 1.5263190153038793 + }, + { + "step": 583, + "lr": 0.0001, + "sup_loss": 1.513668570188107 + }, + { + "step": 584, + "lr": 0.0001, + "sup_loss": 1.5396932472814553 + }, + { + "step": 585, + "lr": 0.0001, + "sup_loss": 1.520343959935798 + }, + { + "step": 586, + "lr": 0.0001, + "sup_loss": 1.5568224663848986 + }, + { + "step": 587, + "lr": 0.0001, + "sup_loss": 1.4930463816877826 + }, + { + "step": 588, + "lr": 0.0001, + "sup_loss": 1.5195441393658515 + }, + { + "step": 589, + "lr": 0.0001, + "sup_loss": 1.5099460511089329 + }, + { + "step": 590, + "lr": 0.0001, + "sup_loss": 1.56036194709874 + }, + { + "step": 591, + "lr": 0.0001, + "sup_loss": 1.5326861985624607 + }, + { + "step": 592, + "lr": 0.0001, + "sup_loss": 1.4728517589052517 + }, + { + "step": 593, + "lr": 0.0001, + "sup_loss": 1.5061764131961108 + }, + { + "step": 594, + "lr": 0.0001, + "sup_loss": 1.5160519949374989 + }, + { + "step": 595, + "lr": 0.0001, + "sup_loss": 1.5009149320838588 + }, + { + "step": 596, + "lr": 0.0001, + "sup_loss": 1.512843956656185 + }, + { + "step": 597, + "lr": 0.0001, + "sup_loss": 1.495373448987571 + }, + { + "step": 598, + "lr": 0.0001, + "sup_loss": 1.5300604215201528 + }, + { + "step": 599, + "lr": 0.0001, + "sup_loss": 1.5271361167507316 + }, + { + "step": 600, + "lr": 0.0001, + "sup_loss": 1.4746719875157162, + "lyap1_mean": -6.706287384033203, + "lyap1_max": -6.6853485107421875, + "lyap_spec_mean": [ + -6.706287384033203, + -6.7072367668151855 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 601, + "lr": 0.0001, + "sup_loss": 1.5336775026150677 + }, + { + "step": 602, + "lr": 0.0001, + "sup_loss": 1.5291573467841881 + }, + { + "step": 603, + "lr": 0.0001, + "sup_loss": 1.5263495770623876 + }, + { + "step": 604, + "lr": 0.0001, + "sup_loss": 1.503451382896976 + }, + { + "step": 605, + "lr": 0.0001, + "sup_loss": 1.5398634285105617 + }, + { + "step": 606, + "lr": 0.0001, + "sup_loss": 1.519265140334756 + }, + { + "step": 607, + "lr": 0.0001, + "sup_loss": 1.5138468165331156 + }, + { + "step": 608, + "lr": 0.0001, + "sup_loss": 1.5262239900340073 + }, + { + "step": 609, + "lr": 0.0001, + "sup_loss": 1.526919684295831 + }, + { + "step": 610, + "lr": 0.0001, + "sup_loss": 1.519283512267841 + }, + { + "step": 611, + "lr": 0.0001, + "sup_loss": 1.5264654126295605 + }, + { + "step": 612, + "lr": 0.0001, + "sup_loss": 1.518608014385772 + }, + { + "step": 613, + "lr": 0.0001, + "sup_loss": 1.483369232582482 + }, + { + "step": 614, + "lr": 0.0001, + "sup_loss": 1.5194200147255776 + }, + { + "step": 615, + "lr": 0.0001, + "sup_loss": 1.509659573928428 + }, + { + "step": 616, + "lr": 0.0001, + "sup_loss": 1.4614213786949402 + }, + { + "step": 617, + "lr": 0.0001, + "sup_loss": 1.519985781853087 + }, + { + "step": 618, + "lr": 0.0001, + "sup_loss": 1.5153756064518529 + }, + { + "step": 619, + "lr": 0.0001, + "sup_loss": 1.4953872974472855 + }, + { + "step": 620, + "lr": 0.0001, + "sup_loss": 1.50964356755188 + }, + { + "step": 621, + "lr": 0.0001, + "sup_loss": 1.5166842103395488 + }, + { + "step": 622, + "lr": 0.0001, + "sup_loss": 1.4827529031202311 + }, + { + "step": 623, + "lr": 0.0001, + "sup_loss": 1.5089609676135278 + }, + { + "step": 624, + "lr": 0.0001, + "sup_loss": 1.4179098266299353 + }, + { + "step": 625, + "lr": 0.0001, + "sup_loss": 1.5462449333163302 + }, + { + "step": 626, + "lr": 0.0001, + "sup_loss": 1.491704724136731 + }, + { + "step": 627, + "lr": 0.0001, + "sup_loss": 1.5296925248055357 + }, + { + "step": 628, + "lr": 0.0001, + "sup_loss": 1.495717675145098 + }, + { + "step": 629, + "lr": 0.0001, + "sup_loss": 1.5094886039242152 + }, + { + "step": 630, + "lr": 0.0001, + "sup_loss": 1.5537490687309552 + }, + { + "step": 631, + "lr": 0.0001, + "sup_loss": 1.5671074028980196 + }, + { + "step": 632, + "lr": 0.0001, + "sup_loss": 1.5291528396725056 + }, + { + "step": 633, + "lr": 0.0001, + "sup_loss": 1.542836361718557 + }, + { + "step": 634, + "lr": 0.0001, + "sup_loss": 1.4853697228480627 + }, + { + "step": 635, + "lr": 0.0001, + "sup_loss": 1.5018737111762246 + }, + { + "step": 636, + "lr": 0.0001, + "sup_loss": 1.4920718193587548 + }, + { + "step": 637, + "lr": 0.0001, + "sup_loss": 1.4889679738842707 + }, + { + "step": 638, + "lr": 0.0001, + "sup_loss": 1.5186764177161212 + }, + { + "step": 639, + "lr": 0.0001, + "sup_loss": 1.5236976351211728 + }, + { + "step": 640, + "lr": 0.0001, + "sup_loss": 1.528840155667301 + }, + { + "step": 641, + "lr": 0.0001, + "sup_loss": 1.53291243411655 + }, + { + "step": 642, + "lr": 0.0001, + "sup_loss": 1.569600070320969 + }, + { + "step": 643, + "lr": 0.0001, + "sup_loss": 1.5498230357632412 + }, + { + "step": 644, + "lr": 0.0001, + "sup_loss": 1.5296614304295055 + }, + { + "step": 645, + "lr": 0.0001, + "sup_loss": 1.5494526011339775 + }, + { + "step": 646, + "lr": 0.0001, + "sup_loss": 1.529450068928431 + }, + { + "step": 647, + "lr": 0.0001, + "sup_loss": 1.5170902165194509 + }, + { + "step": 648, + "lr": 0.0001, + "sup_loss": 1.5290718973416557 + }, + { + "step": 649, + "lr": 0.0001, + "sup_loss": 1.4815761998823769 + }, + { + "step": 650, + "lr": 0.0001, + "sup_loss": 1.5051635719305994, + "lyap1_mean": -6.6470232009887695, + "lyap1_max": -6.628139972686768, + "lyap_spec_mean": [ + -6.647023677825928, + -6.642392635345459 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 651, + "lr": 0.0001, + "sup_loss": 1.5094047529090602 + }, + { + "step": 652, + "lr": 0.0001, + "sup_loss": 1.4997054919315504 + }, + { + "step": 653, + "lr": 0.0001, + "sup_loss": 1.5162976197918159 + }, + { + "step": 654, + "lr": 0.0001, + "sup_loss": 1.4983194976232481 + }, + { + "step": 655, + "lr": 0.0001, + "sup_loss": 1.5127993812520648 + }, + { + "step": 656, + "lr": 0.0001, + "sup_loss": 1.5261014664213866 + }, + { + "step": 657, + "lr": 0.0001, + "sup_loss": 1.4951740231453452 + }, + { + "step": 658, + "lr": 0.0001, + "sup_loss": 1.4817909871854027 + }, + { + "step": 659, + "lr": 0.0001, + "sup_loss": 1.525519173918642 + }, + { + "step": 660, + "lr": 0.0001, + "sup_loss": 1.5023221059259964 + }, + { + "step": 661, + "lr": 0.0001, + "sup_loss": 1.5465929129836793 + }, + { + "step": 662, + "lr": 0.0001, + "sup_loss": 1.511803813875915 + }, + { + "step": 663, + "lr": 0.0001, + "sup_loss": 1.5285347352646839 + }, + { + "step": 664, + "lr": 0.0001, + "sup_loss": 1.5219787259105593 + }, + { + "step": 665, + "lr": 0.0001, + "sup_loss": 1.5184666352898202 + }, + { + "step": 666, + "lr": 0.0001, + "sup_loss": 1.512331622154555 + }, + { + "step": 667, + "lr": 0.0001, + "sup_loss": 1.5048972547747164 + }, + { + "step": 668, + "lr": 0.0001, + "sup_loss": 1.5267053968581568 + }, + { + "step": 669, + "lr": 0.0001, + "sup_loss": 1.520783856316102 + }, + { + "step": 670, + "lr": 0.0001, + "sup_loss": 1.4967002075237184 + }, + { + "step": 671, + "lr": 0.0001, + "sup_loss": 1.5185580478265714 + }, + { + "step": 672, + "lr": 0.0001, + "sup_loss": 1.5326260352431025 + }, + { + "step": 673, + "lr": 0.0001, + "sup_loss": 1.5119897806211688 + }, + { + "step": 674, + "lr": 0.0001, + "sup_loss": 1.5012395810129249 + }, + { + "step": 675, + "lr": 0.0001, + "sup_loss": 1.4716738682943544 + }, + { + "step": 676, + "lr": 0.0001, + "sup_loss": 1.531889695586606 + }, + { + "step": 677, + "lr": 0.0001, + "sup_loss": 1.5015395979322816 + }, + { + "step": 678, + "lr": 0.0001, + "sup_loss": 1.5185524883068886 + }, + { + "step": 679, + "lr": 0.0001, + "sup_loss": 1.5329890913841109 + }, + { + "step": 680, + "lr": 0.0001, + "sup_loss": 1.4862086841848878 + }, + { + "step": 681, + "lr": 0.0001, + "sup_loss": 1.5081771314593237 + }, + { + "step": 682, + "lr": 0.0001, + "sup_loss": 1.5057919255036136 + }, + { + "step": 683, + "lr": 0.0001, + "sup_loss": 1.5287738631947454 + }, + { + "step": 684, + "lr": 0.0001, + "sup_loss": 1.5412355279543468 + }, + { + "step": 685, + "lr": 0.0001, + "sup_loss": 1.5046593794438914 + }, + { + "step": 686, + "lr": 0.0001, + "sup_loss": 1.4978752595818452 + }, + { + "step": 687, + "lr": 0.0001, + "sup_loss": 1.5352642460660617 + }, + { + "step": 688, + "lr": 0.0001, + "sup_loss": 1.4983927779483674 + }, + { + "step": 689, + "lr": 0.0001, + "sup_loss": 1.480772186943008 + }, + { + "step": 690, + "lr": 0.0001, + "sup_loss": 1.5157947002219192 + }, + { + "step": 691, + "lr": 0.0001, + "sup_loss": 1.5287968981414712 + }, + { + "step": 692, + "lr": 0.0001, + "sup_loss": 1.5115796750350312 + }, + { + "step": 693, + "lr": 0.0001, + "sup_loss": 1.5193259959766254 + }, + { + "step": 694, + "lr": 0.0001, + "sup_loss": 1.5110918958324207 + }, + { + "step": 695, + "lr": 0.0001, + "sup_loss": 1.5326753899638526 + }, + { + "step": 696, + "lr": 0.0001, + "sup_loss": 1.505106765876873 + }, + { + "step": 697, + "lr": 0.0001, + "sup_loss": 1.500845572940783 + }, + { + "step": 698, + "lr": 0.0001, + "sup_loss": 1.5316710552295576 + }, + { + "step": 699, + "lr": 0.0001, + "sup_loss": 1.4883620179723598 + }, + { + "step": 700, + "lr": 0.0001, + "sup_loss": 1.5566363929525928, + "lyap1_mean": -6.538327217102051, + "lyap1_max": -6.495978832244873, + "lyap_spec_mean": [ + -6.538326740264893, + -6.544689655303955 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 701, + "lr": 0.0001, + "sup_loss": 1.5287810715506045 + }, + { + "step": 702, + "lr": 0.0001, + "sup_loss": 1.516066487082322 + }, + { + "step": 703, + "lr": 0.0001, + "sup_loss": 1.5137401942306308 + }, + { + "step": 704, + "lr": 0.0001, + "sup_loss": 1.5152303193706085 + }, + { + "step": 705, + "lr": 0.0001, + "sup_loss": 1.5325047690615334 + }, + { + "step": 706, + "lr": 0.0001, + "sup_loss": 1.5041348246173127 + }, + { + "step": 707, + "lr": 0.0001, + "sup_loss": 1.4751987746757644 + }, + { + "step": 708, + "lr": 0.0001, + "sup_loss": 1.5284869096887617 + }, + { + "step": 709, + "lr": 0.0001, + "sup_loss": 1.534997664041701 + }, + { + "step": 710, + "lr": 0.0001, + "sup_loss": 1.5226603736537316 + }, + { + "step": 711, + "lr": 0.0001, + "sup_loss": 1.5188651865398364 + }, + { + "step": 712, + "lr": 0.0001, + "sup_loss": 1.5112746657157887 + }, + { + "step": 713, + "lr": 0.0001, + "sup_loss": 1.4818948793235172 + }, + { + "step": 714, + "lr": 0.0001, + "sup_loss": 1.5122376161315374 + }, + { + "step": 715, + "lr": 0.0001, + "sup_loss": 1.5158005977584161 + }, + { + "step": 716, + "lr": 0.0001, + "sup_loss": 1.5415213410054467 + }, + { + "step": 717, + "lr": 0.0001, + "sup_loss": 1.5010530300237304 + }, + { + "step": 718, + "lr": 0.0001, + "sup_loss": 1.510064641051084 + }, + { + "step": 719, + "lr": 0.0001, + "sup_loss": 1.488125871007282 + }, + { + "step": 720, + "lr": 0.0001, + "sup_loss": 1.5183722180715826 + }, + { + "step": 721, + "lr": 0.0001, + "sup_loss": 1.496824062230423 + }, + { + "step": 722, + "lr": 0.0001, + "sup_loss": 1.5280516945962228 + }, + { + "step": 723, + "lr": 0.0001, + "sup_loss": 1.528585838141417 + }, + { + "step": 724, + "lr": 0.0001, + "sup_loss": 1.5381686652232152 + }, + { + "step": 725, + "lr": 0.0001, + "sup_loss": 1.484148119050607 + }, + { + "step": 726, + "lr": 0.0001, + "sup_loss": 1.5143109927597054 + }, + { + "step": 727, + "lr": 0.0001, + "sup_loss": 1.511654948679459 + }, + { + "step": 728, + "lr": 0.0001, + "sup_loss": 1.532639600339649 + }, + { + "step": 729, + "lr": 0.0001, + "sup_loss": 1.5156672857928635 + }, + { + "step": 730, + "lr": 0.0001, + "sup_loss": 1.515736949131998 + }, + { + "step": 731, + "lr": 0.0001, + "sup_loss": 1.5381653918029696 + }, + { + "step": 732, + "lr": 0.0001, + "sup_loss": 1.4817686566279522 + }, + { + "step": 733, + "lr": 0.0001, + "sup_loss": 1.5350881711968158 + }, + { + "step": 734, + "lr": 0.0001, + "sup_loss": 1.5283042316217763 + }, + { + "step": 735, + "lr": 0.0001, + "sup_loss": 1.5119280295262 + }, + { + "step": 736, + "lr": 0.0001, + "sup_loss": 1.502075078675215 + }, + { + "step": 737, + "lr": 0.0001, + "sup_loss": 1.5380265645418765 + }, + { + "step": 738, + "lr": 0.0001, + "sup_loss": 1.5176291152544727 + }, + { + "step": 739, + "lr": 0.0001, + "sup_loss": 1.5477875553011247 + }, + { + "step": 740, + "lr": 0.0001, + "sup_loss": 1.527247302561592 + }, + { + "step": 741, + "lr": 0.0001, + "sup_loss": 1.494716759296525 + }, + { + "step": 742, + "lr": 0.0001, + "sup_loss": 1.5283759340142355 + }, + { + "step": 743, + "lr": 0.0001, + "sup_loss": 1.5006663614011584 + }, + { + "step": 744, + "lr": 0.0001, + "sup_loss": 1.5210244403816247 + }, + { + "step": 745, + "lr": 0.0001, + "sup_loss": 1.5236166901633954 + }, + { + "step": 746, + "lr": 0.0001, + "sup_loss": 1.5106387834402368 + }, + { + "step": 747, + "lr": 0.0001, + "sup_loss": 1.5039683432611493 + }, + { + "step": 748, + "lr": 0.0001, + "sup_loss": 1.5093944438836167 + }, + { + "step": 749, + "lr": 0.0001, + "sup_loss": 1.5085239521803453 + }, + { + "step": 750, + "lr": 0.0001, + "sup_loss": 1.5201361058761036, + "lyap1_mean": -6.414738655090332, + "lyap1_max": -6.371342658996582, + "lyap_spec_mean": [ + -6.414738655090332, + -6.415633678436279 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 751, + "lr": 0.0001, + "sup_loss": 1.5149260923412404 + }, + { + "step": 752, + "lr": 0.0001, + "sup_loss": 1.5341902670259726 + }, + { + "step": 753, + "lr": 0.0001, + "sup_loss": 1.5147095931145356 + }, + { + "step": 754, + "lr": 0.0001, + "sup_loss": 1.512407652155099 + }, + { + "step": 755, + "lr": 0.0001, + "sup_loss": 1.4839033381321656 + }, + { + "step": 756, + "lr": 0.0001, + "sup_loss": 1.5099877524355274 + }, + { + "step": 757, + "lr": 0.0001, + "sup_loss": 1.5043745540005147 + }, + { + "step": 758, + "lr": 0.0001, + "sup_loss": 1.5015430156634932 + }, + { + "step": 759, + "lr": 0.0001, + "sup_loss": 1.5379622323258437 + }, + { + "step": 760, + "lr": 0.0001, + "sup_loss": 1.5275275436239428 + }, + { + "step": 761, + "lr": 0.0001, + "sup_loss": 1.5204969609836256 + }, + { + "step": 762, + "lr": 0.0001, + "sup_loss": 1.5145343673588703 + }, + { + "step": 763, + "lr": 0.0001, + "sup_loss": 1.520435885713137 + }, + { + "step": 764, + "lr": 0.0001, + "sup_loss": 1.5362379995653999 + }, + { + "step": 765, + "lr": 0.0001, + "sup_loss": 1.53280429578943 + }, + { + "step": 766, + "lr": 0.0001, + "sup_loss": 1.5430548616331885 + }, + { + "step": 767, + "lr": 0.0001, + "sup_loss": 1.5005863037222265 + }, + { + "step": 768, + "lr": 0.0001, + "sup_loss": 1.5098696165419137 + }, + { + "step": 769, + "lr": 0.0001, + "sup_loss": 1.5180128099853307 + }, + { + "step": 770, + "lr": 0.0001, + "sup_loss": 1.5169463420755118 + }, + { + "step": 771, + "lr": 0.0001, + "sup_loss": 1.5186083043919298 + }, + { + "step": 772, + "lr": 0.0001, + "sup_loss": 1.5065191618683647 + }, + { + "step": 773, + "lr": 0.0001, + "sup_loss": 1.5100622769355176 + }, + { + "step": 774, + "lr": 0.0001, + "sup_loss": 1.5401475174904948 + }, + { + "step": 775, + "lr": 0.0001, + "sup_loss": 1.4939349933729393 + }, + { + "step": 776, + "lr": 0.0001, + "sup_loss": 1.5297048457366553 + }, + { + "step": 777, + "lr": 0.0001, + "sup_loss": 1.5339535742003936 + }, + { + "step": 778, + "lr": 0.0001, + "sup_loss": 1.5257886680044794 + }, + { + "step": 779, + "lr": 0.0001, + "sup_loss": 1.4923725842943585 + }, + { + "step": 780, + "lr": 0.0001, + "sup_loss": 1.5433369771805847 + }, + { + "step": 781, + "lr": 0.0001, + "sup_loss": 1.466749345377613 + }, + { + "step": 782, + "lr": 0.0001, + "sup_loss": 1.5100988400396453 + }, + { + "step": 783, + "lr": 0.0001, + "sup_loss": 1.4935840894307528 + }, + { + "step": 784, + "lr": 0.0001, + "sup_loss": 1.5288095409000635 + }, + { + "step": 785, + "lr": 0.0001, + "sup_loss": 1.5140798793701746 + }, + { + "step": 786, + "lr": 0.0001, + "sup_loss": 1.5038278893428967 + }, + { + "step": 787, + "lr": 0.0001, + "sup_loss": 1.4897931579635242 + }, + { + "step": 788, + "lr": 0.0001, + "sup_loss": 1.510297365347192 + }, + { + "step": 789, + "lr": 0.0001, + "sup_loss": 1.5096970725912824 + }, + { + "step": 790, + "lr": 0.0001, + "sup_loss": 1.4563140072803142 + }, + { + "step": 791, + "lr": 0.0001, + "sup_loss": 1.5235519797386794 + }, + { + "step": 792, + "lr": 0.0001, + "sup_loss": 1.554555089402592 + }, + { + "step": 793, + "lr": 0.0001, + "sup_loss": 1.5309656221122645 + }, + { + "step": 794, + "lr": 0.0001, + "sup_loss": 1.5196128662663126 + }, + { + "step": 795, + "lr": 0.0001, + "sup_loss": 1.4970403383711195 + }, + { + "step": 796, + "lr": 0.0001, + "sup_loss": 1.5065915402287726 + }, + { + "step": 797, + "lr": 0.0001, + "sup_loss": 1.4820203727089465 + }, + { + "step": 798, + "lr": 0.0001, + "sup_loss": 1.4932871722006784 + }, + { + "step": 799, + "lr": 0.0001, + "sup_loss": 1.5271928852253274 + }, + { + "step": 800, + "lr": 0.0001, + "sup_loss": 1.5189512274214638, + "lyap1_mean": -6.264998435974121, + "lyap1_max": -6.218259811401367, + "lyap_spec_mean": [ + -6.264998435974121, + -6.257623672485352 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 801, + "lr": 0.0001, + "sup_loss": 1.4794003888566465 + }, + { + "step": 802, + "lr": 0.0001, + "sup_loss": 1.5031133014922253 + }, + { + "step": 803, + "lr": 0.0001, + "sup_loss": 1.5162473584480844 + }, + { + "step": 804, + "lr": 0.0001, + "sup_loss": 1.5171519313246833 + }, + { + "step": 805, + "lr": 0.0001, + "sup_loss": 1.5373420552897847 + }, + { + "step": 806, + "lr": 0.0001, + "sup_loss": 1.5206732390764939 + }, + { + "step": 807, + "lr": 0.0001, + "sup_loss": 1.5203877668446022 + }, + { + "step": 808, + "lr": 0.0001, + "sup_loss": 1.492586592861398 + }, + { + "step": 809, + "lr": 0.0001, + "sup_loss": 1.5039200364706633 + }, + { + "step": 810, + "lr": 0.0001, + "sup_loss": 1.4772981905774536 + }, + { + "step": 811, + "lr": 0.0001, + "sup_loss": 1.5200133260780286 + }, + { + "step": 812, + "lr": 0.0001, + "sup_loss": 1.519401738989703 + }, + { + "step": 813, + "lr": 0.0001, + "sup_loss": 1.5258032459404562 + }, + { + "step": 814, + "lr": 0.0001, + "sup_loss": 1.5377889297754885 + }, + { + "step": 815, + "lr": 0.0001, + "sup_loss": 1.531876294284268 + }, + { + "step": 816, + "lr": 0.0001, + "sup_loss": 1.4890782502081874 + }, + { + "step": 817, + "lr": 0.0001, + "sup_loss": 1.5135778456497797 + }, + { + "step": 818, + "lr": 0.0001, + "sup_loss": 1.4895132250118437 + }, + { + "step": 819, + "lr": 0.0001, + "sup_loss": 1.5319449438162507 + }, + { + "step": 820, + "lr": 0.0001, + "sup_loss": 1.5478730438296613 + }, + { + "step": 821, + "lr": 0.0001, + "sup_loss": 1.5234296605953752 + }, + { + "step": 822, + "lr": 0.0001, + "sup_loss": 1.495539966481088 + }, + { + "step": 823, + "lr": 0.0001, + "sup_loss": 1.4938042542202827 + }, + { + "step": 824, + "lr": 0.0001, + "sup_loss": 1.53036073010849 + }, + { + "step": 825, + "lr": 0.0001, + "sup_loss": 1.5167469429239189 + }, + { + "step": 826, + "lr": 0.0001, + "sup_loss": 1.5224439671219032 + }, + { + "step": 827, + "lr": 0.0001, + "sup_loss": 1.502935736845863 + }, + { + "step": 828, + "lr": 0.0001, + "sup_loss": 1.4923314872325504 + }, + { + "step": 829, + "lr": 0.0001, + "sup_loss": 1.5220883963647738 + }, + { + "step": 830, + "lr": 0.0001, + "sup_loss": 1.5422434343850067 + }, + { + "step": 831, + "lr": 0.0001, + "sup_loss": 1.5321838505506373 + }, + { + "step": 832, + "lr": 0.0001, + "sup_loss": 1.5238810248029964 + }, + { + "step": 833, + "lr": 0.0001, + "sup_loss": 1.506038382435152 + }, + { + "step": 834, + "lr": 0.0001, + "sup_loss": 1.516271936441931 + }, + { + "step": 835, + "lr": 0.0001, + "sup_loss": 1.5141644084304013 + }, + { + "step": 836, + "lr": 0.0001, + "sup_loss": 1.5070632624785256 + }, + { + "step": 837, + "lr": 0.0001, + "sup_loss": 1.5189506063228038 + }, + { + "step": 838, + "lr": 0.0001, + "sup_loss": 1.5222628958504518 + }, + { + "step": 839, + "lr": 0.0001, + "sup_loss": 1.539600923636482 + }, + { + "step": 840, + "lr": 0.0001, + "sup_loss": 1.486930224177299 + }, + { + "step": 841, + "lr": 0.0001, + "sup_loss": 1.5096024197238151 + }, + { + "step": 842, + "lr": 0.0001, + "sup_loss": 1.543960076377166 + }, + { + "step": 843, + "lr": 0.0001, + "sup_loss": 1.5350423459292946 + }, + { + "step": 844, + "lr": 0.0001, + "sup_loss": 1.51947082585353 + }, + { + "step": 845, + "lr": 0.0001, + "sup_loss": 1.5000554733457534 + }, + { + "step": 846, + "lr": 0.0001, + "sup_loss": 1.4854979289135024 + }, + { + "step": 847, + "lr": 0.0001, + "sup_loss": 1.4528837087888837 + }, + { + "step": 848, + "lr": 0.0001, + "sup_loss": 1.4893767215001192 + }, + { + "step": 849, + "lr": 0.0001, + "sup_loss": 1.5116837147336943 + }, + { + "step": 850, + "lr": 0.0001, + "sup_loss": 1.5316996234308449, + "lyap1_mean": -5.944291114807129, + "lyap1_max": -5.860029220581055, + "lyap_spec_mean": [ + -5.944291591644287, + -5.9602861404418945 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 851, + "lr": 0.0001, + "sup_loss": 1.4662178118117368 + }, + { + "step": 852, + "lr": 0.0001, + "sup_loss": 1.496672346771726 + }, + { + "step": 853, + "lr": 0.0001, + "sup_loss": 1.4502686349180454 + }, + { + "step": 854, + "lr": 0.0001, + "sup_loss": 1.5101654747752313 + }, + { + "step": 855, + "lr": 0.0001, + "sup_loss": 1.5287651774536772 + }, + { + "step": 856, + "lr": 0.0001, + "sup_loss": 1.4887774476565343 + }, + { + "step": 857, + "lr": 0.0001, + "sup_loss": 1.5288190638328945 + }, + { + "step": 858, + "lr": 0.0001, + "sup_loss": 1.5331306595376184 + }, + { + "step": 859, + "lr": 0.0001, + "sup_loss": 1.5119847591823368 + }, + { + "step": 860, + "lr": 0.0001, + "sup_loss": 1.4939856897853803 + }, + { + "step": 861, + "lr": 0.0001, + "sup_loss": 1.5054032429188404 + }, + { + "step": 862, + "lr": 0.0001, + "sup_loss": 1.53178351688308 + }, + { + "step": 863, + "lr": 0.0001, + "sup_loss": 1.4975122146837385 + }, + { + "step": 864, + "lr": 0.0001, + "sup_loss": 1.529216706591692 + }, + { + "step": 865, + "lr": 0.0001, + "sup_loss": 1.4858391212571551 + }, + { + "step": 866, + "lr": 0.0001, + "sup_loss": 1.5067555131486585 + }, + { + "step": 867, + "lr": 0.0001, + "sup_loss": 1.4653182542665304 + }, + { + "step": 868, + "lr": 0.0001, + "sup_loss": 1.4939540326558096 + }, + { + "step": 869, + "lr": 0.0001, + "sup_loss": 1.5303096178101399 + }, + { + "step": 870, + "lr": 0.0001, + "sup_loss": 1.516176876584087 + }, + { + "step": 871, + "lr": 0.0001, + "sup_loss": 1.5219778344422048 + }, + { + "step": 872, + "lr": 0.0001, + "sup_loss": 1.4761000122837777 + }, + { + "step": 873, + "lr": 0.0001, + "sup_loss": 1.513006833405729 + }, + { + "step": 874, + "lr": 0.0001, + "sup_loss": 1.5485589422548636 + }, + { + "step": 875, + "lr": 0.0001, + "sup_loss": 1.485695503404262 + }, + { + "step": 876, + "lr": 0.0001, + "sup_loss": 1.4890143451204383 + }, + { + "step": 877, + "lr": 0.0001, + "sup_loss": 1.5175875346328733 + }, + { + "step": 878, + "lr": 0.0001, + "sup_loss": 1.5096965232152808 + }, + { + "step": 879, + "lr": 0.0001, + "sup_loss": 1.5517101778820277 + }, + { + "step": 880, + "lr": 0.0001, + "sup_loss": 1.5209166682770523 + }, + { + "step": 881, + "lr": 0.0001, + "sup_loss": 1.5005544662351054 + }, + { + "step": 882, + "lr": 0.0001, + "sup_loss": 1.4691439649158073 + }, + { + "step": 883, + "lr": 0.0001, + "sup_loss": 1.498696126804384 + }, + { + "step": 884, + "lr": 0.0001, + "sup_loss": 1.5087921193707006 + }, + { + "step": 885, + "lr": 0.0001, + "sup_loss": 1.5023848520057832 + }, + { + "step": 886, + "lr": 0.0001, + "sup_loss": 1.5195873920924312 + }, + { + "step": 887, + "lr": 0.0001, + "sup_loss": 1.5175733846833919 + }, + { + "step": 888, + "lr": 0.0001, + "sup_loss": 1.4952592414580277 + }, + { + "step": 889, + "lr": 0.0001, + "sup_loss": 1.496644038280453 + }, + { + "step": 890, + "lr": 0.0001, + "sup_loss": 1.5191835238179954 + }, + { + "step": 891, + "lr": 0.0001, + "sup_loss": 1.514809273108044 + }, + { + "step": 892, + "lr": 0.0001, + "sup_loss": 1.4885183127445003 + }, + { + "step": 893, + "lr": 0.0001, + "sup_loss": 1.5126444543487492 + }, + { + "step": 894, + "lr": 0.0001, + "sup_loss": 1.5258446574175875 + }, + { + "step": 895, + "lr": 0.0001, + "sup_loss": 1.4691680650241499 + }, + { + "step": 896, + "lr": 0.0001, + "sup_loss": 1.5170742203735634 + }, + { + "step": 897, + "lr": 0.0001, + "sup_loss": 1.4924416535416078 + }, + { + "step": 898, + "lr": 0.0001, + "sup_loss": 1.5363673680659329 + }, + { + "step": 899, + "lr": 0.0001, + "sup_loss": 1.536372445667659 + }, + { + "step": 900, + "lr": 0.0001, + "sup_loss": 1.4997625964904768, + "lyap1_mean": -5.652142524719238, + "lyap1_max": -5.594020366668701, + "lyap_spec_mean": [ + -5.652142524719238, + -5.6429667472839355 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 901, + "lr": 0.0001, + "sup_loss": 1.507499264067011 + }, + { + "step": 902, + "lr": 0.0001, + "sup_loss": 1.5167841992518767 + }, + { + "step": 903, + "lr": 0.0001, + "sup_loss": 1.467195067448345 + }, + { + "step": 904, + "lr": 0.0001, + "sup_loss": 1.5224154370923002 + }, + { + "step": 905, + "lr": 0.0001, + "sup_loss": 1.5317981279164885 + }, + { + "step": 906, + "lr": 0.0001, + "sup_loss": 1.5291796176202899 + }, + { + "step": 907, + "lr": 0.0001, + "sup_loss": 1.5141419183145175 + }, + { + "step": 908, + "lr": 0.0001, + "sup_loss": 1.486324712345776 + }, + { + "step": 909, + "lr": 0.0001, + "sup_loss": 1.4968871261056726 + }, + { + "step": 910, + "lr": 0.0001, + "sup_loss": 1.4828435875444144 + }, + { + "step": 911, + "lr": 0.0001, + "sup_loss": 1.4933315598782024 + }, + { + "step": 912, + "lr": 0.0001, + "sup_loss": 1.4868035687515695 + }, + { + "step": 913, + "lr": 0.0001, + "sup_loss": 1.5397040122960144 + }, + { + "step": 914, + "lr": 0.0001, + "sup_loss": 1.5136633188998756 + }, + { + "step": 915, + "lr": 0.0001, + "sup_loss": 1.4473687510979423 + }, + { + "step": 916, + "lr": 0.0001, + "sup_loss": 1.5355209072731966 + }, + { + "step": 917, + "lr": 0.0001, + "sup_loss": 1.463715133289889 + }, + { + "step": 918, + "lr": 0.0001, + "sup_loss": 1.524152528957749 + }, + { + "step": 919, + "lr": 0.0001, + "sup_loss": 1.5144340083338805 + }, + { + "step": 920, + "lr": 0.0001, + "sup_loss": 1.4936449496755215 + }, + { + "step": 921, + "lr": 0.0001, + "sup_loss": 1.551149291445036 + }, + { + "step": 922, + "lr": 0.0001, + "sup_loss": 1.475193621978353 + }, + { + "step": 923, + "lr": 0.0001, + "sup_loss": 1.5072904697448237 + }, + { + "step": 924, + "lr": 0.0001, + "sup_loss": 1.5034295320627853 + }, + { + "step": 925, + "lr": 0.0001, + "sup_loss": 1.4687878097170466 + }, + { + "step": 926, + "lr": 0.0001, + "sup_loss": 1.497240080963438 + }, + { + "step": 927, + "lr": 0.0001, + "sup_loss": 1.453493570747067 + }, + { + "step": 928, + "lr": 0.0001, + "sup_loss": 1.5272355249073333 + }, + { + "step": 929, + "lr": 0.0001, + "sup_loss": 1.4954138710957656 + }, + { + "step": 930, + "lr": 0.0001, + "sup_loss": 1.532836496771222 + }, + { + "step": 931, + "lr": 0.0001, + "sup_loss": 1.5243129092733296 + }, + { + "step": 932, + "lr": 0.0001, + "sup_loss": 1.5095965680375445 + }, + { + "step": 933, + "lr": 0.0001, + "sup_loss": 1.5081322883135968 + }, + { + "step": 934, + "lr": 0.0001, + "sup_loss": 1.5183249592661394 + }, + { + "step": 935, + "lr": 0.0001, + "sup_loss": 1.5093233281872678 + }, + { + "step": 936, + "lr": 0.0001, + "sup_loss": 1.509689676873144 + }, + { + "step": 937, + "lr": 0.0001, + "sup_loss": 1.5201641118624953 + }, + { + "step": 938, + "lr": 0.0001, + "sup_loss": 1.434867776183133 + }, + { + "step": 939, + "lr": 0.0001, + "sup_loss": 1.498886252878764 + }, + { + "step": 940, + "lr": 0.0001, + "sup_loss": 1.5011932339312852 + }, + { + "step": 941, + "lr": 0.0001, + "sup_loss": 1.5241598202101634 + }, + { + "step": 942, + "lr": 0.0001, + "sup_loss": 1.505778298169391 + }, + { + "step": 943, + "lr": 0.0001, + "sup_loss": 1.519579321968116 + }, + { + "step": 944, + "lr": 0.0001, + "sup_loss": 1.5079361183127624 + }, + { + "step": 945, + "lr": 0.0001, + "sup_loss": 1.5037163830793818 + }, + { + "step": 946, + "lr": 0.0001, + "sup_loss": 1.4689941026742286 + }, + { + "step": 947, + "lr": 0.0001, + "sup_loss": 1.5639875285326823 + }, + { + "step": 948, + "lr": 0.0001, + "sup_loss": 1.5392894189821704 + }, + { + "step": 949, + "lr": 0.0001, + "sup_loss": 1.5055158758145308 + }, + { + "step": 950, + "lr": 0.0001, + "sup_loss": 1.518267165943395, + "lyap1_mean": -5.448543548583984, + "lyap1_max": -5.374388694763184, + "lyap_spec_mean": [ + -5.448543548583984, + -5.42637825012207 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 951, + "lr": 0.0001, + "sup_loss": 1.4824273966788006 + }, + { + "step": 952, + "lr": 0.0001, + "sup_loss": 1.5323886198047028 + }, + { + "step": 953, + "lr": 0.0001, + "sup_loss": 1.5218753245403334 + }, + { + "step": 954, + "lr": 0.0001, + "sup_loss": 1.5106468562324793 + }, + { + "step": 955, + "lr": 0.0001, + "sup_loss": 1.4902749499708472 + }, + { + "step": 956, + "lr": 0.0001, + "sup_loss": 1.5072560962565862 + }, + { + "step": 957, + "lr": 0.0001, + "sup_loss": 1.5081858010439633 + }, + { + "step": 958, + "lr": 0.0001, + "sup_loss": 1.517830286889684 + }, + { + "step": 959, + "lr": 0.0001, + "sup_loss": 1.5292294570510734 + }, + { + "step": 960, + "lr": 0.0001, + "sup_loss": 1.5284211025221013 + }, + { + "step": 961, + "lr": 0.0001, + "sup_loss": 1.4869179701446167 + }, + { + "step": 962, + "lr": 0.0001, + "sup_loss": 1.5167554418953664 + }, + { + "step": 963, + "lr": 0.0001, + "sup_loss": 1.5022203921109658 + }, + { + "step": 964, + "lr": 0.0001, + "sup_loss": 1.5082677144024677 + }, + { + "step": 965, + "lr": 0.0001, + "sup_loss": 1.4737698001462685 + }, + { + "step": 966, + "lr": 0.0001, + "sup_loss": 1.5188335949555747 + }, + { + "step": 967, + "lr": 0.0001, + "sup_loss": 1.5274473696800166 + }, + { + "step": 968, + "lr": 0.0001, + "sup_loss": 1.514180666119481 + }, + { + "step": 969, + "lr": 0.0001, + "sup_loss": 1.5202551960844581 + }, + { + "step": 970, + "lr": 0.0001, + "sup_loss": 1.5143891182957718 + }, + { + "step": 971, + "lr": 0.0001, + "sup_loss": 1.504930148063865 + }, + { + "step": 972, + "lr": 0.0001, + "sup_loss": 1.501472242033977 + }, + { + "step": 973, + "lr": 0.0001, + "sup_loss": 1.5109138293566082 + }, + { + "step": 974, + "lr": 0.0001, + "sup_loss": 1.521006606339136 + }, + { + "step": 975, + "lr": 0.0001, + "sup_loss": 1.4974613446060685 + }, + { + "step": 976, + "lr": 0.0001, + "sup_loss": 1.5050752003953027 + }, + { + "step": 977, + "lr": 0.0001, + "sup_loss": 1.5218882284540702 + }, + { + "step": 978, + "lr": 0.0001, + "sup_loss": 1.54280851663081 + }, + { + "step": 979, + "lr": 0.0001, + "sup_loss": 1.4553324585789031 + }, + { + "step": 980, + "lr": 0.0001, + "sup_loss": 1.5596921913721995 + }, + { + "step": 981, + "lr": 0.0001, + "sup_loss": 1.4786041536384265 + }, + { + "step": 982, + "lr": 0.0001, + "sup_loss": 1.4971809060144017 + }, + { + "step": 983, + "lr": 0.0001, + "sup_loss": 1.5295897375459258 + }, + { + "step": 984, + "lr": 0.0001, + "sup_loss": 1.5299979674474378 + }, + { + "step": 985, + "lr": 0.0001, + "sup_loss": 1.456327333071445 + }, + { + "step": 986, + "lr": 0.0001, + "sup_loss": 1.5378813472825856 + }, + { + "step": 987, + "lr": 0.0001, + "sup_loss": 1.491217848090841 + }, + { + "step": 988, + "lr": 0.0001, + "sup_loss": 1.5116251776299399 + }, + { + "step": 989, + "lr": 0.0001, + "sup_loss": 1.474147240169287 + }, + { + "step": 990, + "lr": 0.0001, + "sup_loss": 1.4907397097415611 + }, + { + "step": 991, + "lr": 0.0001, + "sup_loss": 1.4992047493859184 + }, + { + "step": 992, + "lr": 0.0001, + "sup_loss": 1.4937366874149411 + }, + { + "step": 993, + "lr": 0.0001, + "sup_loss": 1.4772547257883624 + }, + { + "step": 994, + "lr": 0.0001, + "sup_loss": 1.4871965155865938 + }, + { + "step": 995, + "lr": 0.0001, + "sup_loss": 1.547781844799699 + }, + { + "step": 996, + "lr": 0.0001, + "sup_loss": 1.4729891039962326 + }, + { + "step": 997, + "lr": 0.0001, + "sup_loss": 1.4800220846633856 + }, + { + "step": 998, + "lr": 0.0001, + "sup_loss": 1.5138811195467095 + }, + { + "step": 999, + "lr": 0.0001, + "sup_loss": 1.4800734524212662 + }, + { + "step": 1000, + "lr": 0.0001, + "sup_loss": 1.4862077489691015, + "lyap1_mean": -5.086652755737305, + "lyap1_max": -5.010838508605957, + "lyap_spec_mean": [ + -5.086652755737305, + -5.101796627044678 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1001, + "lr": 0.0001, + "sup_loss": 1.491190142941294 + }, + { + "step": 1002, + "lr": 0.0001, + "sup_loss": 1.5338051140823528 + }, + { + "step": 1003, + "lr": 0.0001, + "sup_loss": 1.453768709725902 + }, + { + "step": 1004, + "lr": 0.0001, + "sup_loss": 1.4950069717523864 + }, + { + "step": 1005, + "lr": 0.0001, + "sup_loss": 1.4921631368346473 + }, + { + "step": 1006, + "lr": 0.0001, + "sup_loss": 1.5298900700411682 + }, + { + "step": 1007, + "lr": 0.0001, + "sup_loss": 1.4875213403635956 + }, + { + "step": 1008, + "lr": 0.0001, + "sup_loss": 1.4811045802261913 + }, + { + "step": 1009, + "lr": 0.0001, + "sup_loss": 1.5250101180805309 + }, + { + "step": 1010, + "lr": 0.0001, + "sup_loss": 1.5033493294925102 + }, + { + "step": 1011, + "lr": 0.0001, + "sup_loss": 1.5128267721867283 + }, + { + "step": 1012, + "lr": 0.0001, + "sup_loss": 1.4947289338333436 + }, + { + "step": 1013, + "lr": 0.0001, + "sup_loss": 1.4925525129247341 + }, + { + "step": 1014, + "lr": 0.0001, + "sup_loss": 1.4996314639909738 + }, + { + "step": 1015, + "lr": 0.0001, + "sup_loss": 1.492959768370052 + }, + { + "step": 1016, + "lr": 0.0001, + "sup_loss": 1.5091553965420217 + }, + { + "step": 1017, + "lr": 0.0001, + "sup_loss": 1.523810286677666 + }, + { + "step": 1018, + "lr": 0.0001, + "sup_loss": 1.483313092948707 + }, + { + "step": 1019, + "lr": 0.0001, + "sup_loss": 1.5150976478960907 + }, + { + "step": 1020, + "lr": 0.0001, + "sup_loss": 1.475309542182523 + }, + { + "step": 1021, + "lr": 0.0001, + "sup_loss": 1.500195908589669 + }, + { + "step": 1022, + "lr": 0.0001, + "sup_loss": 1.4945939977510452 + }, + { + "step": 1023, + "lr": 0.0001, + "sup_loss": 1.4250120115069176 + }, + { + "step": 1024, + "lr": 0.0001, + "sup_loss": 1.4918787542757612 + }, + { + "step": 1025, + "lr": 0.0001, + "sup_loss": 1.4991129912983376 + }, + { + "step": 1026, + "lr": 0.0001, + "sup_loss": 1.492617385449115 + }, + { + "step": 1027, + "lr": 0.0001, + "sup_loss": 1.5160458983109 + }, + { + "step": 1028, + "lr": 0.0001, + "sup_loss": 1.4941115004329355 + }, + { + "step": 1029, + "lr": 0.0001, + "sup_loss": 1.496451859922323 + }, + { + "step": 1030, + "lr": 0.0001, + "sup_loss": 1.4951053205183618 + }, + { + "step": 1031, + "lr": 0.0001, + "sup_loss": 1.4938560898638187 + }, + { + "step": 1032, + "lr": 0.0001, + "sup_loss": 1.4774130117810043 + }, + { + "step": 1033, + "lr": 0.0001, + "sup_loss": 1.5095015063091686 + }, + { + "step": 1034, + "lr": 0.0001, + "sup_loss": 1.5070117186327943 + }, + { + "step": 1035, + "lr": 0.0001, + "sup_loss": 1.4768238123518271 + }, + { + "step": 1036, + "lr": 0.0001, + "sup_loss": 1.476529080284256 + }, + { + "step": 1037, + "lr": 0.0001, + "sup_loss": 1.494776177357163 + }, + { + "step": 1038, + "lr": 0.0001, + "sup_loss": 1.5404689844677595 + }, + { + "step": 1039, + "lr": 0.0001, + "sup_loss": 1.5116941628376854 + }, + { + "step": 1040, + "lr": 0.0001, + "sup_loss": 1.4807356397180933 + }, + { + "step": 1041, + "lr": 0.0001, + "sup_loss": 1.498028787710557 + }, + { + "step": 1042, + "lr": 0.0001, + "sup_loss": 1.4754103357553532 + }, + { + "step": 1043, + "lr": 0.0001, + "sup_loss": 1.5053698487795235 + }, + { + "step": 1044, + "lr": 0.0001, + "sup_loss": 1.5296728770508057 + }, + { + "step": 1045, + "lr": 0.0001, + "sup_loss": 1.5086255065998997 + }, + { + "step": 1046, + "lr": 0.0001, + "sup_loss": 1.4916575167454593 + }, + { + "step": 1047, + "lr": 0.0001, + "sup_loss": 1.4932460950040167 + }, + { + "step": 1048, + "lr": 0.0001, + "sup_loss": 1.5022055807348158 + }, + { + "step": 1049, + "lr": 0.0001, + "sup_loss": 1.4846387059737416 + }, + { + "step": 1050, + "lr": 0.0001, + "sup_loss": 1.4583279112164924, + "lyap1_mean": -4.985368251800537, + "lyap1_max": -4.9488115310668945, + "lyap_spec_mean": [ + -4.985368251800537, + -5.0083394050598145 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1051, + "lr": 0.0001, + "sup_loss": 1.5079011066488937 + }, + { + "step": 1052, + "lr": 0.0001, + "sup_loss": 1.5007515289918683 + }, + { + "step": 1053, + "lr": 0.0001, + "sup_loss": 1.534958945999648 + }, + { + "step": 1054, + "lr": 0.0001, + "sup_loss": 1.4963135998085617 + }, + { + "step": 1055, + "lr": 0.0001, + "sup_loss": 1.4930120557032553 + }, + { + "step": 1056, + "lr": 0.0001, + "sup_loss": 1.512046037240657 + }, + { + "step": 1057, + "lr": 0.0001, + "sup_loss": 1.5058272313052585 + }, + { + "step": 1058, + "lr": 0.0001, + "sup_loss": 1.481208655387988 + }, + { + "step": 1059, + "lr": 0.0001, + "sup_loss": 1.5237169406639706 + }, + { + "step": 1060, + "lr": 0.0001, + "sup_loss": 1.5153822571783004 + }, + { + "step": 1061, + "lr": 0.0001, + "sup_loss": 1.477981358976096 + }, + { + "step": 1062, + "lr": 0.0001, + "sup_loss": 1.493432202847611 + }, + { + "step": 1063, + "lr": 0.0001, + "sup_loss": 1.4770211775614548 + }, + { + "step": 1064, + "lr": 0.0001, + "sup_loss": 1.4696978837949088 + }, + { + "step": 1065, + "lr": 0.0001, + "sup_loss": 1.4943629670203953 + }, + { + "step": 1066, + "lr": 0.0001, + "sup_loss": 1.49505678933645 + }, + { + "step": 1067, + "lr": 0.0001, + "sup_loss": 1.495147677887443 + }, + { + "step": 1068, + "lr": 0.0001, + "sup_loss": 1.4844499947850718 + }, + { + "step": 1069, + "lr": 0.0001, + "sup_loss": 1.4543617916322704 + }, + { + "step": 1070, + "lr": 0.0001, + "sup_loss": 1.5000871222605547 + }, + { + "step": 1071, + "lr": 0.0001, + "sup_loss": 1.502567682384034 + }, + { + "step": 1072, + "lr": 0.0001, + "sup_loss": 1.488314001438542 + }, + { + "step": 1073, + "lr": 0.0001, + "sup_loss": 1.488304624795962 + }, + { + "step": 1074, + "lr": 0.0001, + "sup_loss": 1.494284739754046 + }, + { + "step": 1075, + "lr": 0.0001, + "sup_loss": 1.4727882874363902 + }, + { + "step": 1076, + "lr": 0.0001, + "sup_loss": 1.511807986328729 + }, + { + "step": 1077, + "lr": 0.0001, + "sup_loss": 1.4870160784126345 + }, + { + "step": 1078, + "lr": 0.0001, + "sup_loss": 1.4837270015578496 + }, + { + "step": 1079, + "lr": 0.0001, + "sup_loss": 1.4875352025713129 + }, + { + "step": 1080, + "lr": 0.0001, + "sup_loss": 1.5024935978982221 + }, + { + "step": 1081, + "lr": 0.0001, + "sup_loss": 1.4819859872644976 + }, + { + "step": 1082, + "lr": 0.0001, + "sup_loss": 1.5043254784455866 + }, + { + "step": 1083, + "lr": 0.0001, + "sup_loss": 1.4645798123131413 + }, + { + "step": 1084, + "lr": 0.0001, + "sup_loss": 1.4915036619135214 + }, + { + "step": 1085, + "lr": 0.0001, + "sup_loss": 1.5015138581699607 + }, + { + "step": 1086, + "lr": 0.0001, + "sup_loss": 1.4957361692727997 + }, + { + "step": 1087, + "lr": 0.0001, + "sup_loss": 1.5477593496318298 + }, + { + "step": 1088, + "lr": 0.0001, + "sup_loss": 1.5067801216534944 + }, + { + "step": 1089, + "lr": 0.0001, + "sup_loss": 1.4995562337114996 + }, + { + "step": 1090, + "lr": 0.0001, + "sup_loss": 1.4612830614799217 + }, + { + "step": 1091, + "lr": 0.0001, + "sup_loss": 1.4742256666063809 + }, + { + "step": 1092, + "lr": 0.0001, + "sup_loss": 1.4724958822731793 + }, + { + "step": 1093, + "lr": 0.0001, + "sup_loss": 1.4612374227310905 + }, + { + "step": 1094, + "lr": 0.0001, + "sup_loss": 1.4505542347531546 + }, + { + "step": 1095, + "lr": 0.0001, + "sup_loss": 1.5367597739936414 + }, + { + "step": 1096, + "lr": 0.0001, + "sup_loss": 1.4695740675730589 + }, + { + "step": 1097, + "lr": 0.0001, + "sup_loss": 1.5071457895270661 + }, + { + "step": 1098, + "lr": 0.0001, + "sup_loss": 1.5137372385953056 + }, + { + "step": 1099, + "lr": 0.0001, + "sup_loss": 1.5164012149254902 + }, + { + "step": 1100, + "lr": 0.0001, + "sup_loss": 1.5074580993196545, + "lyap1_mean": -5.024776458740234, + "lyap1_max": -4.9834303855896, + "lyap_spec_mean": [ + -5.024776458740234, + -5.0234293937683105 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1101, + "lr": 0.0001, + "sup_loss": 1.4893846557301706 + }, + { + "step": 1102, + "lr": 0.0001, + "sup_loss": 1.4810311211838452 + }, + { + "step": 1103, + "lr": 0.0001, + "sup_loss": 1.4881358655681456 + }, + { + "step": 1104, + "lr": 0.0001, + "sup_loss": 1.4940961901532852 + }, + { + "step": 1105, + "lr": 0.0001, + "sup_loss": 1.4753095966685144 + }, + { + "step": 1106, + "lr": 0.0001, + "sup_loss": 1.5248464308547973 + }, + { + "step": 1107, + "lr": 0.0001, + "sup_loss": 1.5093487508039454 + }, + { + "step": 1108, + "lr": 0.0001, + "sup_loss": 1.5367204201189768 + }, + { + "step": 1109, + "lr": 0.0001, + "sup_loss": 1.4951622618093052 + }, + { + "step": 1110, + "lr": 0.0001, + "sup_loss": 1.4954845796681129 + }, + { + "step": 1111, + "lr": 0.0001, + "sup_loss": 1.4917942853885013 + }, + { + "step": 1112, + "lr": 0.0001, + "sup_loss": 1.4262000511817663 + }, + { + "step": 1113, + "lr": 0.0001, + "sup_loss": 1.5043712728927912 + }, + { + "step": 1114, + "lr": 0.0001, + "sup_loss": 1.484278422177646 + }, + { + "step": 1115, + "lr": 0.0001, + "sup_loss": 1.5219035891965151 + }, + { + "step": 1116, + "lr": 0.0001, + "sup_loss": 1.4950970748440897 + }, + { + "step": 1117, + "lr": 0.0001, + "sup_loss": 1.4943428543594146 + }, + { + "step": 1118, + "lr": 0.0001, + "sup_loss": 1.4871422744331029 + }, + { + "step": 1119, + "lr": 0.0001, + "sup_loss": 1.505205653908111 + }, + { + "step": 1120, + "lr": 0.0001, + "sup_loss": 1.4624580150776079 + }, + { + "step": 1121, + "lr": 0.0001, + "sup_loss": 1.478784498763538 + }, + { + "step": 1122, + "lr": 0.0001, + "sup_loss": 1.4715949945354443 + }, + { + "step": 1123, + "lr": 0.0001, + "sup_loss": 1.4957458644069577 + }, + { + "step": 1124, + "lr": 0.0001, + "sup_loss": 1.4827836699290668 + }, + { + "step": 1125, + "lr": 0.0001, + "sup_loss": 1.4743856874260983 + }, + { + "step": 1126, + "lr": 0.0001, + "sup_loss": 1.471642222687305 + }, + { + "step": 1127, + "lr": 0.0001, + "sup_loss": 1.4942140766445238 + }, + { + "step": 1128, + "lr": 0.0001, + "sup_loss": 1.4964272399481269 + }, + { + "step": 1129, + "lr": 0.0001, + "sup_loss": 1.489714735807674 + }, + { + "step": 1130, + "lr": 0.0001, + "sup_loss": 1.4795423848023082 + }, + { + "step": 1131, + "lr": 0.0001, + "sup_loss": 1.5017106888127012 + }, + { + "step": 1132, + "lr": 0.0001, + "sup_loss": 1.4714448207224442 + }, + { + "step": 1133, + "lr": 0.0001, + "sup_loss": 1.4626417158867993 + }, + { + "step": 1134, + "lr": 0.0001, + "sup_loss": 1.4491329459413975 + }, + { + "step": 1135, + "lr": 0.0001, + "sup_loss": 1.4617050052344747 + }, + { + "step": 1136, + "lr": 0.0001, + "sup_loss": 1.4998257578902021 + }, + { + "step": 1137, + "lr": 0.0001, + "sup_loss": 1.4998440252848666 + }, + { + "step": 1138, + "lr": 0.0001, + "sup_loss": 1.4846175202054472 + }, + { + "step": 1139, + "lr": 0.0001, + "sup_loss": 1.4718216224866734 + }, + { + "step": 1140, + "lr": 0.0001, + "sup_loss": 1.5081759004682445 + }, + { + "step": 1141, + "lr": 0.0001, + "sup_loss": 1.4969522608011026 + }, + { + "step": 1142, + "lr": 0.0001, + "sup_loss": 1.4690122810816595 + }, + { + "step": 1143, + "lr": 0.0001, + "sup_loss": 1.4955443523100043 + }, + { + "step": 1144, + "lr": 0.0001, + "sup_loss": 1.4927066398111735 + }, + { + "step": 1145, + "lr": 0.0001, + "sup_loss": 1.4725230333581665 + }, + { + "step": 1146, + "lr": 0.0001, + "sup_loss": 1.4701228574799046 + }, + { + "step": 1147, + "lr": 0.0001, + "sup_loss": 1.4780445694839879 + }, + { + "step": 1148, + "lr": 0.0001, + "sup_loss": 1.4693462829861517 + }, + { + "step": 1149, + "lr": 0.0001, + "sup_loss": 1.5100726072285409 + }, + { + "step": 1150, + "lr": 0.0001, + "sup_loss": 1.480903277719113, + "lyap1_mean": -4.9455885887146, + "lyap1_max": -4.850168228149414, + "lyap_spec_mean": [ + -4.9455885887146, + -4.929689407348633 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1151, + "lr": 0.0001, + "sup_loss": 1.4507184038835605 + }, + { + "step": 1152, + "lr": 0.0001, + "sup_loss": 1.502905456958449 + }, + { + "step": 1153, + "lr": 0.0001, + "sup_loss": 1.4731891271094737 + }, + { + "step": 1154, + "lr": 0.0001, + "sup_loss": 1.5114034459966716 + }, + { + "step": 1155, + "lr": 0.0001, + "sup_loss": 1.4851636061949942 + }, + { + "step": 1156, + "lr": 0.0001, + "sup_loss": 1.5153188881042223 + }, + { + "step": 1157, + "lr": 0.0001, + "sup_loss": 1.53415556606997 + }, + { + "step": 1158, + "lr": 0.0001, + "sup_loss": 1.4927789967832232 + }, + { + "step": 1159, + "lr": 0.0001, + "sup_loss": 1.4748716306954783 + }, + { + "step": 1160, + "lr": 0.0001, + "sup_loss": 1.5037391789734031 + }, + { + "step": 1161, + "lr": 0.0001, + "sup_loss": 1.4909826070120134 + }, + { + "step": 1162, + "lr": 0.0001, + "sup_loss": 1.4882852503259236 + }, + { + "step": 1163, + "lr": 0.0001, + "sup_loss": 1.476347461882321 + }, + { + "step": 1164, + "lr": 0.0001, + "sup_loss": 1.500105285760655 + }, + { + "step": 1165, + "lr": 0.0001, + "sup_loss": 1.459256843071044 + }, + { + "step": 1166, + "lr": 0.0001, + "sup_loss": 1.4948051454166613 + }, + { + "step": 1167, + "lr": 0.0001, + "sup_loss": 1.4487606220173448 + }, + { + "step": 1168, + "lr": 0.0001, + "sup_loss": 1.4773466283799845 + }, + { + "step": 1169, + "lr": 0.0001, + "sup_loss": 1.4666078537550662 + }, + { + "step": 1170, + "lr": 0.0001, + "sup_loss": 1.4845902155303574 + }, + { + "step": 1171, + "lr": 0.0001, + "sup_loss": 1.4556790254014549 + }, + { + "step": 1172, + "lr": 0.0001, + "sup_loss": 1.4850841195107127 + }, + { + "step": 1173, + "lr": 0.0001, + "sup_loss": 1.5182421729232407 + }, + { + "step": 1174, + "lr": 0.0001, + "sup_loss": 1.476394210737806 + }, + { + "step": 1175, + "lr": 0.0001, + "sup_loss": 1.4821449618214182 + }, + { + "step": 1176, + "lr": 0.0001, + "sup_loss": 1.5024094032370132 + }, + { + "step": 1177, + "lr": 0.0001, + "sup_loss": 1.5022114492114407 + }, + { + "step": 1178, + "lr": 0.0001, + "sup_loss": 1.4621831924589657 + }, + { + "step": 1179, + "lr": 0.0001, + "sup_loss": 1.4811286199451543 + }, + { + "step": 1180, + "lr": 0.0001, + "sup_loss": 1.4578099169211276 + }, + { + "step": 1181, + "lr": 0.0001, + "sup_loss": 1.456907282548804 + }, + { + "step": 1182, + "lr": 0.0001, + "sup_loss": 1.4740023330832586 + }, + { + "step": 1183, + "lr": 0.0001, + "sup_loss": 1.4920635428211853 + }, + { + "step": 1184, + "lr": 0.0001, + "sup_loss": 1.5024858560779706 + }, + { + "step": 1185, + "lr": 0.0001, + "sup_loss": 1.5038948187638805 + }, + { + "step": 1186, + "lr": 0.0001, + "sup_loss": 1.4676908572162626 + }, + { + "step": 1187, + "lr": 0.0001, + "sup_loss": 1.488254510144115 + }, + { + "step": 1188, + "lr": 0.0001, + "sup_loss": 1.4263772574814746 + }, + { + "step": 1189, + "lr": 0.0001, + "sup_loss": 1.4676478384293827 + }, + { + "step": 1190, + "lr": 0.0001, + "sup_loss": 1.479789183280758 + }, + { + "step": 1191, + "lr": 0.0001, + "sup_loss": 1.4711267705653097 + }, + { + "step": 1192, + "lr": 0.0001, + "sup_loss": 1.4949702804907512 + }, + { + "step": 1193, + "lr": 0.0001, + "sup_loss": 1.513007655717897 + }, + { + "step": 1194, + "lr": 0.0001, + "sup_loss": 1.4509345633164903 + }, + { + "step": 1195, + "lr": 0.0001, + "sup_loss": 1.4685760250534123 + }, + { + "step": 1196, + "lr": 0.0001, + "sup_loss": 1.480123566158829 + }, + { + "step": 1197, + "lr": 0.0001, + "sup_loss": 1.418077246836308 + }, + { + "step": 1198, + "lr": 0.0001, + "sup_loss": 1.490917450497209 + }, + { + "step": 1199, + "lr": 0.0001, + "sup_loss": 1.5074936351952484 + }, + { + "step": 1200, + "lr": 0.0001, + "sup_loss": 1.4327738160400691, + "lyap1_mean": -4.980145454406738, + "lyap1_max": -4.894585132598877, + "lyap_spec_mean": [ + -4.980145454406738, + -4.967625617980957 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1201, + "lr": 0.0001, + "sup_loss": 1.4895817401426568 + }, + { + "step": 1202, + "lr": 0.0001, + "sup_loss": 1.4899703577499632 + }, + { + "step": 1203, + "lr": 0.0001, + "sup_loss": 1.4024933659507388 + }, + { + "step": 1204, + "lr": 0.0001, + "sup_loss": 1.5022236802821578 + }, + { + "step": 1205, + "lr": 0.0001, + "sup_loss": 1.4897626062931595 + }, + { + "step": 1206, + "lr": 0.0001, + "sup_loss": 1.5044620497089163 + }, + { + "step": 1207, + "lr": 0.0001, + "sup_loss": 1.4643798769968492 + }, + { + "step": 1208, + "lr": 0.0001, + "sup_loss": 1.4491454287091519 + }, + { + "step": 1209, + "lr": 0.0001, + "sup_loss": 1.4219676043723457 + }, + { + "step": 1210, + "lr": 0.0001, + "sup_loss": 1.4867866233353422 + }, + { + "step": 1211, + "lr": 0.0001, + "sup_loss": 1.4936261592840825 + }, + { + "step": 1212, + "lr": 0.0001, + "sup_loss": 1.493904028254398 + }, + { + "step": 1213, + "lr": 0.0001, + "sup_loss": 1.4308489828733526 + }, + { + "step": 1214, + "lr": 0.0001, + "sup_loss": 1.4677810549300505 + }, + { + "step": 1215, + "lr": 0.0001, + "sup_loss": 1.3859949750578329 + }, + { + "step": 1216, + "lr": 0.0001, + "sup_loss": 1.4505806596494422 + }, + { + "step": 1217, + "lr": 0.0001, + "sup_loss": 1.4778397790206566 + }, + { + "step": 1218, + "lr": 0.0001, + "sup_loss": 1.440790028206717 + }, + { + "step": 1219, + "lr": 0.0001, + "sup_loss": 1.4726534285928603 + }, + { + "step": 1220, + "lr": 0.0001, + "sup_loss": 1.4858277006105567 + }, + { + "step": 1221, + "lr": 0.0001, + "sup_loss": 1.4535088818412911 + }, + { + "step": 1222, + "lr": 0.0001, + "sup_loss": 1.4167877079974307 + }, + { + "step": 1223, + "lr": 0.0001, + "sup_loss": 1.4929940592460411 + }, + { + "step": 1224, + "lr": 0.0001, + "sup_loss": 1.5014798452852063 + }, + { + "step": 1225, + "lr": 0.0001, + "sup_loss": 1.4830507593952498 + }, + { + "step": 1226, + "lr": 0.0001, + "sup_loss": 1.4618634931835748 + }, + { + "step": 1227, + "lr": 0.0001, + "sup_loss": 1.5204372552744971 + }, + { + "step": 1228, + "lr": 0.0001, + "sup_loss": 1.4946793222065595 + }, + { + "step": 1229, + "lr": 0.0001, + "sup_loss": 1.483768416583394 + }, + { + "step": 1230, + "lr": 0.0001, + "sup_loss": 1.4740270725400642 + }, + { + "step": 1231, + "lr": 0.0001, + "sup_loss": 1.48345038920087 + }, + { + "step": 1232, + "lr": 0.0001, + "sup_loss": 1.4616529497138675 + }, + { + "step": 1233, + "lr": 0.0001, + "sup_loss": 1.4716175096811974 + }, + { + "step": 1234, + "lr": 0.0001, + "sup_loss": 1.457797067601594 + }, + { + "step": 1235, + "lr": 0.0001, + "sup_loss": 1.4874279390796319 + }, + { + "step": 1236, + "lr": 0.0001, + "sup_loss": 1.4636663214377188 + }, + { + "step": 1237, + "lr": 0.0001, + "sup_loss": 1.4504392628921492 + }, + { + "step": 1238, + "lr": 0.0001, + "sup_loss": 1.4170344608345224 + }, + { + "step": 1239, + "lr": 0.0001, + "sup_loss": 1.4893669447572702 + }, + { + "step": 1240, + "lr": 0.0001, + "sup_loss": 1.480716245937543 + }, + { + "step": 1241, + "lr": 0.0001, + "sup_loss": 1.4729937213032487 + }, + { + "step": 1242, + "lr": 0.0001, + "sup_loss": 1.4760532853462685 + }, + { + "step": 1243, + "lr": 0.0001, + "sup_loss": 1.4538871862153457 + }, + { + "step": 1244, + "lr": 0.0001, + "sup_loss": 1.4691397369385832 + }, + { + "step": 1245, + "lr": 0.0001, + "sup_loss": 1.4865630523389617 + }, + { + "step": 1246, + "lr": 0.0001, + "sup_loss": 1.4951783866766888 + }, + { + "step": 1247, + "lr": 0.0001, + "sup_loss": 1.4658872212811977 + }, + { + "step": 1248, + "lr": 0.0001, + "sup_loss": 1.4641396308973371 + }, + { + "step": 1249, + "lr": 0.0001, + "sup_loss": 1.4879901314026 + }, + { + "step": 1250, + "lr": 0.0001, + "sup_loss": 1.4687423186118318, + "lyap1_mean": -4.899415969848633, + "lyap1_max": -4.83683443069458, + "lyap_spec_mean": [ + -4.899415969848633, + -4.950930595397949 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1251, + "lr": 0.0001, + "sup_loss": 1.4469572613294321 + }, + { + "step": 1252, + "lr": 0.0001, + "sup_loss": 1.4581797062249233 + }, + { + "step": 1253, + "lr": 0.0001, + "sup_loss": 1.5087221661119814 + }, + { + "step": 1254, + "lr": 0.0001, + "sup_loss": 1.4923270443285557 + }, + { + "step": 1255, + "lr": 0.0001, + "sup_loss": 1.4851067653432983 + }, + { + "step": 1256, + "lr": 0.0001, + "sup_loss": 1.4747097076636708 + }, + { + "step": 1257, + "lr": 0.0001, + "sup_loss": 1.4987728722195657 + }, + { + "step": 1258, + "lr": 0.0001, + "sup_loss": 1.4576866146886762 + }, + { + "step": 1259, + "lr": 0.0001, + "sup_loss": 1.4267594419820548 + }, + { + "step": 1260, + "lr": 0.0001, + "sup_loss": 1.4895388922870765 + }, + { + "step": 1261, + "lr": 0.0001, + "sup_loss": 1.445517901260158 + }, + { + "step": 1262, + "lr": 0.0001, + "sup_loss": 1.473762977426208 + }, + { + "step": 1263, + "lr": 0.0001, + "sup_loss": 1.4828652079630404 + }, + { + "step": 1264, + "lr": 0.0001, + "sup_loss": 1.4991972207034314 + }, + { + "step": 1265, + "lr": 0.0001, + "sup_loss": 1.4757345657404937 + }, + { + "step": 1266, + "lr": 0.0001, + "sup_loss": 1.5010977982497316 + }, + { + "step": 1267, + "lr": 0.0001, + "sup_loss": 1.402599351061424 + }, + { + "step": 1268, + "lr": 0.0001, + "sup_loss": 1.4980575569678551 + }, + { + "step": 1269, + "lr": 0.0001, + "sup_loss": 1.478188775275099 + }, + { + "step": 1270, + "lr": 0.0001, + "sup_loss": 1.5047462702079168 + }, + { + "step": 1271, + "lr": 0.0001, + "sup_loss": 1.453459764416147 + }, + { + "step": 1272, + "lr": 0.0001, + "sup_loss": 1.5077941281889407 + }, + { + "step": 1273, + "lr": 0.0001, + "sup_loss": 1.466721068102257 + }, + { + "step": 1274, + "lr": 0.0001, + "sup_loss": 1.4807916531840593 + }, + { + "step": 1275, + "lr": 0.0001, + "sup_loss": 1.449105744514764 + }, + { + "step": 1276, + "lr": 0.0001, + "sup_loss": 1.458009877940556 + }, + { + "step": 1277, + "lr": 0.0001, + "sup_loss": 1.4687265051814076 + }, + { + "step": 1278, + "lr": 0.0001, + "sup_loss": 1.4424690589508722 + }, + { + "step": 1279, + "lr": 0.0001, + "sup_loss": 1.4693114190501486 + }, + { + "step": 1280, + "lr": 0.0001, + "sup_loss": 1.4626151462849437 + }, + { + "step": 1281, + "lr": 0.0001, + "sup_loss": 1.4482632170416359 + }, + { + "step": 1282, + "lr": 0.0001, + "sup_loss": 1.4939683942967972 + }, + { + "step": 1283, + "lr": 0.0001, + "sup_loss": 1.4078564557088988 + }, + { + "step": 1284, + "lr": 0.0001, + "sup_loss": 1.4524933791214658 + }, + { + "step": 1285, + "lr": 0.0001, + "sup_loss": 1.4720895571225794 + }, + { + "step": 1286, + "lr": 0.0001, + "sup_loss": 1.4614224348921792 + }, + { + "step": 1287, + "lr": 0.0001, + "sup_loss": 1.4823583720322766 + }, + { + "step": 1288, + "lr": 0.0001, + "sup_loss": 1.5181830741607076 + }, + { + "step": 1289, + "lr": 0.0001, + "sup_loss": 1.5083781865830375 + }, + { + "step": 1290, + "lr": 0.0001, + "sup_loss": 1.4343800580328865 + }, + { + "step": 1291, + "lr": 0.0001, + "sup_loss": 1.501462498856272 + }, + { + "step": 1292, + "lr": 0.0001, + "sup_loss": 1.49106349856551 + }, + { + "step": 1293, + "lr": 0.0001, + "sup_loss": 1.4634810108772984 + }, + { + "step": 1294, + "lr": 0.0001, + "sup_loss": 1.445329403388514 + }, + { + "step": 1295, + "lr": 0.0001, + "sup_loss": 1.491845201882513 + }, + { + "step": 1296, + "lr": 0.0001, + "sup_loss": 1.4986002971463355 + }, + { + "step": 1297, + "lr": 0.0001, + "sup_loss": 1.456849861066217 + }, + { + "step": 1298, + "lr": 0.0001, + "sup_loss": 1.5209139225170956 + }, + { + "step": 1299, + "lr": 0.0001, + "sup_loss": 1.4783268760775852 + }, + { + "step": 1300, + "lr": 0.0001, + "sup_loss": 1.4505696377645774, + "lyap1_mean": -4.9549150466918945, + "lyap1_max": -4.879584789276123, + "lyap_spec_mean": [ + -4.9549150466918945, + -4.968719482421875 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1301, + "lr": 0.0001, + "sup_loss": 1.460384983999942 + }, + { + "step": 1302, + "lr": 0.0001, + "sup_loss": 1.517781936006953 + }, + { + "step": 1303, + "lr": 0.0001, + "sup_loss": 1.4854018418932051 + }, + { + "step": 1304, + "lr": 0.0001, + "sup_loss": 1.4924999559426448 + }, + { + "step": 1305, + "lr": 0.0001, + "sup_loss": 1.5417023057297385 + }, + { + "step": 1306, + "lr": 0.0001, + "sup_loss": 1.4740305175611248 + }, + { + "step": 1307, + "lr": 0.0001, + "sup_loss": 1.4857927905801596 + }, + { + "step": 1308, + "lr": 0.0001, + "sup_loss": 1.415051865940042 + }, + { + "step": 1309, + "lr": 0.0001, + "sup_loss": 1.4648704114524878 + }, + { + "step": 1310, + "lr": 0.0001, + "sup_loss": 1.4349438325914907 + }, + { + "step": 1311, + "lr": 0.0001, + "sup_loss": 1.4585966529935726 + }, + { + "step": 1312, + "lr": 0.0001, + "sup_loss": 1.4586155395149896 + }, + { + "step": 1313, + "lr": 0.0001, + "sup_loss": 1.477302356256303 + }, + { + "step": 1314, + "lr": 0.0001, + "sup_loss": 1.5036037677806355 + }, + { + "step": 1315, + "lr": 0.0001, + "sup_loss": 1.4675150214295212 + }, + { + "step": 1316, + "lr": 0.0001, + "sup_loss": 1.4865319754601845 + }, + { + "step": 1317, + "lr": 0.0001, + "sup_loss": 1.4912920452304554 + }, + { + "step": 1318, + "lr": 0.0001, + "sup_loss": 1.4759324266604805 + }, + { + "step": 1319, + "lr": 0.0001, + "sup_loss": 1.5282260128519345 + }, + { + "step": 1320, + "lr": 0.0001, + "sup_loss": 1.4750823000308122 + }, + { + "step": 1321, + "lr": 0.0001, + "sup_loss": 1.4503966787587672 + }, + { + "step": 1322, + "lr": 0.0001, + "sup_loss": 1.4776967328834663 + }, + { + "step": 1323, + "lr": 0.0001, + "sup_loss": 1.4601244767576667 + }, + { + "step": 1324, + "lr": 0.0001, + "sup_loss": 1.4531779622048628 + }, + { + "step": 1325, + "lr": 0.0001, + "sup_loss": 1.497494493622028 + }, + { + "step": 1326, + "lr": 0.0001, + "sup_loss": 1.4553385998154538 + }, + { + "step": 1327, + "lr": 0.0001, + "sup_loss": 1.4501649768439246 + }, + { + "step": 1328, + "lr": 0.0001, + "sup_loss": 1.4325750957136725 + }, + { + "step": 1329, + "lr": 0.0001, + "sup_loss": 1.4671514805063177 + }, + { + "step": 1330, + "lr": 0.0001, + "sup_loss": 1.4455857124314446 + }, + { + "step": 1331, + "lr": 0.0001, + "sup_loss": 1.4859139999051265 + }, + { + "step": 1332, + "lr": 0.0001, + "sup_loss": 1.4598386827419108 + }, + { + "step": 1333, + "lr": 0.0001, + "sup_loss": 1.4529397783925984 + }, + { + "step": 1334, + "lr": 0.0001, + "sup_loss": 1.4755278841286046 + }, + { + "step": 1335, + "lr": 0.0001, + "sup_loss": 1.3942360789764172 + }, + { + "step": 1336, + "lr": 0.0001, + "sup_loss": 1.4987030744783227 + }, + { + "step": 1337, + "lr": 0.0001, + "sup_loss": 1.4462084641083286 + }, + { + "step": 1338, + "lr": 0.0001, + "sup_loss": 1.4502301667462927 + }, + { + "step": 1339, + "lr": 0.0001, + "sup_loss": 1.4737479860943496 + }, + { + "step": 1340, + "lr": 0.0001, + "sup_loss": 1.487379088274462 + }, + { + "step": 1341, + "lr": 0.0001, + "sup_loss": 1.4623950037545321 + }, + { + "step": 1342, + "lr": 0.0001, + "sup_loss": 1.447335404682255 + }, + { + "step": 1343, + "lr": 0.0001, + "sup_loss": 1.4739215994972084 + }, + { + "step": 1344, + "lr": 0.0001, + "sup_loss": 1.5032003694394298 + }, + { + "step": 1345, + "lr": 0.0001, + "sup_loss": 1.4593605151972133 + }, + { + "step": 1346, + "lr": 0.0001, + "sup_loss": 1.4460440573893067 + }, + { + "step": 1347, + "lr": 0.0001, + "sup_loss": 1.4545720742066124 + }, + { + "step": 1348, + "lr": 0.0001, + "sup_loss": 1.4920996736069647 + }, + { + "step": 1349, + "lr": 0.0001, + "sup_loss": 1.4504111254454797 + }, + { + "step": 1350, + "lr": 0.0001, + "sup_loss": 1.4689092344518515, + "lyap1_mean": -4.931465148925781, + "lyap1_max": -4.89593505859375, + "lyap_spec_mean": [ + -4.931465148925781, + -4.935503005981445 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1351, + "lr": 0.0001, + "sup_loss": 1.4630826446384495 + }, + { + "step": 1352, + "lr": 0.0001, + "sup_loss": 1.4299442977172152 + }, + { + "step": 1353, + "lr": 0.0001, + "sup_loss": 1.4421396787085525 + }, + { + "step": 1354, + "lr": 0.0001, + "sup_loss": 1.457529412612607 + }, + { + "step": 1355, + "lr": 0.0001, + "sup_loss": 1.4598766565615744 + }, + { + "step": 1356, + "lr": 0.0001, + "sup_loss": 1.467753297812535 + }, + { + "step": 1357, + "lr": 0.0001, + "sup_loss": 1.4281446846028276 + }, + { + "step": 1358, + "lr": 0.0001, + "sup_loss": 1.4391846346674546 + }, + { + "step": 1359, + "lr": 0.0001, + "sup_loss": 1.4700838855903684 + }, + { + "step": 1360, + "lr": 0.0001, + "sup_loss": 1.4692868012953695 + }, + { + "step": 1361, + "lr": 0.0001, + "sup_loss": 1.479793221633773 + }, + { + "step": 1362, + "lr": 0.0001, + "sup_loss": 1.4854180015532912 + }, + { + "step": 1363, + "lr": 0.0001, + "sup_loss": 1.4483145014422605 + }, + { + "step": 1364, + "lr": 0.0001, + "sup_loss": 1.4606855841318707 + }, + { + "step": 1365, + "lr": 0.0001, + "sup_loss": 1.4730099942735924 + }, + { + "step": 1366, + "lr": 0.0001, + "sup_loss": 1.4549413542224845 + }, + { + "step": 1367, + "lr": 0.0001, + "sup_loss": 1.4974572226217275 + }, + { + "step": 1368, + "lr": 0.0001, + "sup_loss": 1.4834459848526274 + }, + { + "step": 1369, + "lr": 0.0001, + "sup_loss": 1.4963073446846717 + }, + { + "step": 1370, + "lr": 0.0001, + "sup_loss": 1.3891793064379003 + }, + { + "step": 1371, + "lr": 0.0001, + "sup_loss": 1.5137110719177653 + }, + { + "step": 1372, + "lr": 0.0001, + "sup_loss": 1.4540415287576216 + }, + { + "step": 1373, + "lr": 0.0001, + "sup_loss": 1.4793176702172128 + }, + { + "step": 1374, + "lr": 0.0001, + "sup_loss": 1.487491825446896 + }, + { + "step": 1375, + "lr": 0.0001, + "sup_loss": 1.5073274954065587 + }, + { + "step": 1376, + "lr": 0.0001, + "sup_loss": 1.479394108427727 + }, + { + "step": 1377, + "lr": 0.0001, + "sup_loss": 1.446787371202537 + }, + { + "step": 1378, + "lr": 0.0001, + "sup_loss": 1.435867942260591 + }, + { + "step": 1379, + "lr": 0.0001, + "sup_loss": 1.4557625878849318 + }, + { + "step": 1380, + "lr": 0.0001, + "sup_loss": 1.4732116926036665 + }, + { + "step": 1381, + "lr": 0.0001, + "sup_loss": 1.4051078634930474 + }, + { + "step": 1382, + "lr": 0.0001, + "sup_loss": 1.466746186176767 + }, + { + "step": 1383, + "lr": 0.0001, + "sup_loss": 1.46929751694308 + }, + { + "step": 1384, + "lr": 0.0001, + "sup_loss": 1.463057672518489 + }, + { + "step": 1385, + "lr": 0.0001, + "sup_loss": 1.4259808233941291 + }, + { + "step": 1386, + "lr": 0.0001, + "sup_loss": 1.455293708515534 + }, + { + "step": 1387, + "lr": 0.0001, + "sup_loss": 1.4550107447406377 + }, + { + "step": 1388, + "lr": 0.0001, + "sup_loss": 1.454115771654303 + }, + { + "step": 1389, + "lr": 0.0001, + "sup_loss": 1.4786664280358452 + }, + { + "step": 1390, + "lr": 0.0001, + "sup_loss": 1.455955020995784 + }, + { + "step": 1391, + "lr": 0.0001, + "sup_loss": 1.4659499119455552 + }, + { + "step": 1392, + "lr": 0.0001, + "sup_loss": 1.451174394821315 + }, + { + "step": 1393, + "lr": 0.0001, + "sup_loss": 1.4465310232613278 + }, + { + "step": 1394, + "lr": 0.0001, + "sup_loss": 1.4320645250557789 + }, + { + "step": 1395, + "lr": 0.0001, + "sup_loss": 1.4676390112981756 + }, + { + "step": 1396, + "lr": 0.0001, + "sup_loss": 1.5132170845575477 + }, + { + "step": 1397, + "lr": 0.0001, + "sup_loss": 1.4234981403832874 + }, + { + "step": 1398, + "lr": 0.0001, + "sup_loss": 1.4042491299832027 + }, + { + "step": 1399, + "lr": 0.0001, + "sup_loss": 1.462284596693642 + }, + { + "step": 1400, + "lr": 0.0001, + "sup_loss": 1.445975186773351, + "lyap1_mean": -4.836701393127441, + "lyap1_max": -4.783886432647705, + "lyap_spec_mean": [ + -4.8367018699646, + -4.896517276763916 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1401, + "lr": 0.0001, + "sup_loss": 1.425526613166654 + }, + { + "step": 1402, + "lr": 0.0001, + "sup_loss": 1.4634727501607048 + }, + { + "step": 1403, + "lr": 0.0001, + "sup_loss": 1.4154321319087628 + }, + { + "step": 1404, + "lr": 0.0001, + "sup_loss": 1.468091586947968 + }, + { + "step": 1405, + "lr": 0.0001, + "sup_loss": 1.476015856226677 + }, + { + "step": 1406, + "lr": 0.0001, + "sup_loss": 1.4469313944832158 + }, + { + "step": 1407, + "lr": 0.0001, + "sup_loss": 1.4648772473230929 + }, + { + "step": 1408, + "lr": 0.0001, + "sup_loss": 1.4353985894400934 + }, + { + "step": 1409, + "lr": 0.0001, + "sup_loss": 1.471189726692836 + }, + { + "step": 1410, + "lr": 0.0001, + "sup_loss": 1.4349447640461945 + }, + { + "step": 1411, + "lr": 0.0001, + "sup_loss": 1.459744562843906 + }, + { + "step": 1412, + "lr": 0.0001, + "sup_loss": 1.4746893257621285 + }, + { + "step": 1413, + "lr": 0.0001, + "sup_loss": 1.4643818213289568 + }, + { + "step": 1414, + "lr": 0.0001, + "sup_loss": 1.4549503817906437 + }, + { + "step": 1415, + "lr": 0.0001, + "sup_loss": 1.4391135190587492 + }, + { + "step": 1416, + "lr": 0.0001, + "sup_loss": 1.4326492161649624 + }, + { + "step": 1417, + "lr": 0.0001, + "sup_loss": 1.4720987897305684 + }, + { + "step": 1418, + "lr": 0.0001, + "sup_loss": 1.4914051889134379 + }, + { + "step": 1419, + "lr": 0.0001, + "sup_loss": 1.4495293383437353 + }, + { + "step": 1420, + "lr": 0.0001, + "sup_loss": 1.4190264207680032 + }, + { + "step": 1421, + "lr": 0.0001, + "sup_loss": 1.4440298753641012 + }, + { + "step": 1422, + "lr": 0.0001, + "sup_loss": 1.4541722232559824 + }, + { + "step": 1423, + "lr": 0.0001, + "sup_loss": 1.451851009894193 + }, + { + "step": 1424, + "lr": 0.0001, + "sup_loss": 1.4817215110014974 + }, + { + "step": 1425, + "lr": 0.0001, + "sup_loss": 1.4576574069684372 + }, + { + "step": 1426, + "lr": 0.0001, + "sup_loss": 1.4468147058934735 + }, + { + "step": 1427, + "lr": 0.0001, + "sup_loss": 1.4661241096381898 + }, + { + "step": 1428, + "lr": 0.0001, + "sup_loss": 1.4414842098636724 + }, + { + "step": 1429, + "lr": 0.0001, + "sup_loss": 1.4400921159499058 + }, + { + "step": 1430, + "lr": 0.0001, + "sup_loss": 1.4618246404247086 + }, + { + "step": 1431, + "lr": 0.0001, + "sup_loss": 1.4238758998484815 + }, + { + "step": 1432, + "lr": 0.0001, + "sup_loss": 1.4122807748429786 + }, + { + "step": 1433, + "lr": 0.0001, + "sup_loss": 1.4696382313630718 + }, + { + "step": 1434, + "lr": 0.0001, + "sup_loss": 1.4699219728407953 + }, + { + "step": 1435, + "lr": 0.0001, + "sup_loss": 1.4435760705898395 + }, + { + "step": 1436, + "lr": 0.0001, + "sup_loss": 1.4491098498119803 + }, + { + "step": 1437, + "lr": 0.0001, + "sup_loss": 1.4636085678164543 + }, + { + "step": 1438, + "lr": 0.0001, + "sup_loss": 1.435290432757181 + }, + { + "step": 1439, + "lr": 0.0001, + "sup_loss": 1.4312625206038057 + }, + { + "step": 1440, + "lr": 0.0001, + "sup_loss": 1.4504287630939405 + }, + { + "step": 1441, + "lr": 0.0001, + "sup_loss": 1.4118009765397788 + }, + { + "step": 1442, + "lr": 0.0001, + "sup_loss": 1.4566654497466118 + }, + { + "step": 1443, + "lr": 0.0001, + "sup_loss": 1.4492776564966285 + }, + { + "step": 1444, + "lr": 0.0001, + "sup_loss": 1.3958982549544174 + }, + { + "step": 1445, + "lr": 0.0001, + "sup_loss": 1.47066031940578 + }, + { + "step": 1446, + "lr": 0.0001, + "sup_loss": 1.462014501980225 + }, + { + "step": 1447, + "lr": 0.0001, + "sup_loss": 1.430744536039194 + }, + { + "step": 1448, + "lr": 0.0001, + "sup_loss": 1.4803154673721786 + }, + { + "step": 1449, + "lr": 0.0001, + "sup_loss": 1.4390528509936122 + }, + { + "step": 1450, + "lr": 0.0001, + "sup_loss": 1.4671590561530587, + "lyap1_mean": -4.90616512298584, + "lyap1_max": -4.82309103012085, + "lyap_spec_mean": [ + -4.90616512298584, + -4.88002872467041 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1451, + "lr": 0.0001, + "sup_loss": 1.491449835409722 + }, + { + "step": 1452, + "lr": 0.0001, + "sup_loss": 1.4102554179793172 + }, + { + "step": 1453, + "lr": 0.0001, + "sup_loss": 1.3989063628407754 + }, + { + "step": 1454, + "lr": 0.0001, + "sup_loss": 1.472127869804765 + }, + { + "step": 1455, + "lr": 0.0001, + "sup_loss": 1.4634677411154382 + }, + { + "step": 1456, + "lr": 0.0001, + "sup_loss": 1.4765568745353184 + }, + { + "step": 1457, + "lr": 0.0001, + "sup_loss": 1.4573270010805905 + }, + { + "step": 1458, + "lr": 0.0001, + "sup_loss": 1.4550360625273984 + }, + { + "step": 1459, + "lr": 0.0001, + "sup_loss": 1.4136294666326934 + }, + { + "step": 1460, + "lr": 0.0001, + "sup_loss": 1.442390763243285 + }, + { + "step": 1461, + "lr": 0.0001, + "sup_loss": 1.4629446204575114 + }, + { + "step": 1462, + "lr": 0.0001, + "sup_loss": 1.4599644884978145 + }, + { + "step": 1463, + "lr": 0.0001, + "sup_loss": 1.4711858370095716 + }, + { + "step": 1464, + "lr": 0.0001, + "sup_loss": 1.4041374902763835 + }, + { + "step": 1465, + "lr": 0.0001, + "sup_loss": 1.4374500732754496 + }, + { + "step": 1466, + "lr": 0.0001, + "sup_loss": 1.4513513570721417 + }, + { + "step": 1467, + "lr": 0.0001, + "sup_loss": 1.4173516926917245 + }, + { + "step": 1468, + "lr": 0.0001, + "sup_loss": 1.461530739996572 + }, + { + "step": 1469, + "lr": 0.0001, + "sup_loss": 1.4226043641662203 + }, + { + "step": 1470, + "lr": 0.0001, + "sup_loss": 1.451586577456039 + }, + { + "step": 1471, + "lr": 0.0001, + "sup_loss": 1.4430202592766468 + }, + { + "step": 1472, + "lr": 0.0001, + "sup_loss": 1.4487111015767749 + }, + { + "step": 1473, + "lr": 0.0001, + "sup_loss": 1.4578467531434212 + }, + { + "step": 1474, + "lr": 0.0001, + "sup_loss": 1.4121042796802712 + }, + { + "step": 1475, + "lr": 0.0001, + "sup_loss": 1.4828702623885843 + }, + { + "step": 1476, + "lr": 0.0001, + "sup_loss": 1.4432026368424578 + }, + { + "step": 1477, + "lr": 0.0001, + "sup_loss": 1.424240077660403 + }, + { + "step": 1478, + "lr": 0.0001, + "sup_loss": 1.4356999725345851 + }, + { + "step": 1479, + "lr": 0.0001, + "sup_loss": 1.4055916905473094 + }, + { + "step": 1480, + "lr": 0.0001, + "sup_loss": 1.4637976175365572 + }, + { + "step": 1481, + "lr": 0.0001, + "sup_loss": 1.458403314810014 + }, + { + "step": 1482, + "lr": 0.0001, + "sup_loss": 1.4927108373228621 + }, + { + "step": 1483, + "lr": 0.0001, + "sup_loss": 1.4489999078809652 + }, + { + "step": 1484, + "lr": 0.0001, + "sup_loss": 1.4278160973008365 + }, + { + "step": 1485, + "lr": 0.0001, + "sup_loss": 1.4410087245834038 + }, + { + "step": 1486, + "lr": 0.0001, + "sup_loss": 1.4096582771348374 + }, + { + "step": 1487, + "lr": 0.0001, + "sup_loss": 1.4415387910578528 + }, + { + "step": 1488, + "lr": 0.0001, + "sup_loss": 1.4421186568768058 + }, + { + "step": 1489, + "lr": 0.0001, + "sup_loss": 1.4539014787301254 + }, + { + "step": 1490, + "lr": 0.0001, + "sup_loss": 1.4398542386156385 + }, + { + "step": 1491, + "lr": 0.0001, + "sup_loss": 1.4351546744594235 + }, + { + "step": 1492, + "lr": 0.0001, + "sup_loss": 1.4473557335491596 + }, + { + "step": 1493, + "lr": 0.0001, + "sup_loss": 1.4526134050475805 + }, + { + "step": 1494, + "lr": 0.0001, + "sup_loss": 1.449403060501902 + }, + { + "step": 1495, + "lr": 0.0001, + "sup_loss": 1.4483793022647264 + }, + { + "step": 1496, + "lr": 0.0001, + "sup_loss": 1.4505850445617374 + }, + { + "step": 1497, + "lr": 0.0001, + "sup_loss": 1.4417696126903843 + }, + { + "step": 1498, + "lr": 0.0001, + "sup_loss": 1.4573266014393726 + }, + { + "step": 1499, + "lr": 0.0001, + "sup_loss": 1.3771375701434592 + }, + { + "step": 1500, + "lr": 0.0001, + "sup_loss": 1.3766876470720837, + "lyap1_mean": -4.871829986572266, + "lyap1_max": -4.84684944152832, + "lyap_spec_mean": [ + -4.871829986572266, + -4.8450117111206055 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1501, + "lr": 0.0001, + "sup_loss": 1.3965918804816742 + }, + { + "step": 1502, + "lr": 0.0001, + "sup_loss": 1.4468647406829607 + }, + { + "step": 1503, + "lr": 0.0001, + "sup_loss": 1.4254322832396327 + }, + { + "step": 1504, + "lr": 0.0001, + "sup_loss": 1.4524092202807979 + }, + { + "step": 1505, + "lr": 0.0001, + "sup_loss": 1.442207869589765 + }, + { + "step": 1506, + "lr": 0.0001, + "sup_loss": 1.459412210629993 + }, + { + "step": 1507, + "lr": 0.0001, + "sup_loss": 1.4374820854662866 + }, + { + "step": 1508, + "lr": 0.0001, + "sup_loss": 1.4085379451374989 + }, + { + "step": 1509, + "lr": 0.0001, + "sup_loss": 1.443730493127249 + }, + { + "step": 1510, + "lr": 0.0001, + "sup_loss": 1.4674984512768257 + }, + { + "step": 1511, + "lr": 0.0001, + "sup_loss": 1.4462923080916368 + }, + { + "step": 1512, + "lr": 0.0001, + "sup_loss": 1.3202777433618544 + }, + { + "step": 1513, + "lr": 0.0001, + "sup_loss": 1.4651239241236453 + }, + { + "step": 1514, + "lr": 0.0001, + "sup_loss": 1.4437704752606575 + }, + { + "step": 1515, + "lr": 0.0001, + "sup_loss": 1.4552223612865343 + }, + { + "step": 1516, + "lr": 0.0001, + "sup_loss": 1.4456883634826196 + }, + { + "step": 1517, + "lr": 0.0001, + "sup_loss": 1.4408543382277836 + }, + { + "step": 1518, + "lr": 0.0001, + "sup_loss": 1.4419442236808644 + }, + { + "step": 1519, + "lr": 0.0001, + "sup_loss": 1.440560727647496 + }, + { + "step": 1520, + "lr": 0.0001, + "sup_loss": 1.419030841214394 + }, + { + "step": 1521, + "lr": 0.0001, + "sup_loss": 1.4686379857966065 + }, + { + "step": 1522, + "lr": 0.0001, + "sup_loss": 1.4333427271638608 + }, + { + "step": 1523, + "lr": 0.0001, + "sup_loss": 1.4711165418108552 + }, + { + "step": 1524, + "lr": 0.0001, + "sup_loss": 1.4490470654712322 + }, + { + "step": 1525, + "lr": 0.0001, + "sup_loss": 1.4390122524656563 + }, + { + "step": 1526, + "lr": 0.0001, + "sup_loss": 1.4106675291259594 + }, + { + "step": 1527, + "lr": 0.0001, + "sup_loss": 1.4050782705555793 + }, + { + "step": 1528, + "lr": 0.0001, + "sup_loss": 1.4506016534995017 + }, + { + "step": 1529, + "lr": 0.0001, + "sup_loss": 1.4642485397074907 + }, + { + "step": 1530, + "lr": 0.0001, + "sup_loss": 1.49480964273257 + }, + { + "step": 1531, + "lr": 0.0001, + "sup_loss": 1.4415406669082693 + }, + { + "step": 1532, + "lr": 0.0001, + "sup_loss": 1.4249572828119925 + }, + { + "step": 1533, + "lr": 0.0001, + "sup_loss": 1.4758269501521326 + }, + { + "step": 1534, + "lr": 0.0001, + "sup_loss": 1.4443047736953802 + }, + { + "step": 1535, + "lr": 0.0001, + "sup_loss": 1.413901495120456 + }, + { + "step": 1536, + "lr": 0.0001, + "sup_loss": 1.4784263085091247 + }, + { + "step": 1537, + "lr": 0.0001, + "sup_loss": 1.4521063973237631 + }, + { + "step": 1538, + "lr": 0.0001, + "sup_loss": 1.4147111108265757 + }, + { + "step": 1539, + "lr": 0.0001, + "sup_loss": 1.4730862181915314 + }, + { + "step": 1540, + "lr": 0.0001, + "sup_loss": 1.4251807375381318 + }, + { + "step": 1541, + "lr": 0.0001, + "sup_loss": 1.447337750390472 + }, + { + "step": 1542, + "lr": 0.0001, + "sup_loss": 1.4213962976530492 + }, + { + "step": 1543, + "lr": 0.0001, + "sup_loss": 1.3839344815549173 + }, + { + "step": 1544, + "lr": 0.0001, + "sup_loss": 1.438176941126204 + }, + { + "step": 1545, + "lr": 0.0001, + "sup_loss": 1.4495826050872176 + }, + { + "step": 1546, + "lr": 0.0001, + "sup_loss": 1.398046447358952 + }, + { + "step": 1547, + "lr": 0.0001, + "sup_loss": 1.4727749053136245 + }, + { + "step": 1548, + "lr": 0.0001, + "sup_loss": 1.4108699284492 + }, + { + "step": 1549, + "lr": 0.0001, + "sup_loss": 1.4307992397035778 + }, + { + "step": 1550, + "lr": 0.0001, + "sup_loss": 1.460253181661509, + "lyap1_mean": -4.80469274520874, + "lyap1_max": -4.705941677093506, + "lyap_spec_mean": [ + -4.804693222045898, + -4.79709529876709 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1551, + "lr": 0.0001, + "sup_loss": 1.4320098646343116 + }, + { + "step": 1552, + "lr": 0.0001, + "sup_loss": 1.4420628696579727 + }, + { + "step": 1553, + "lr": 0.0001, + "sup_loss": 1.4154910895199624 + }, + { + "step": 1554, + "lr": 0.0001, + "sup_loss": 1.4539745642951691 + }, + { + "step": 1555, + "lr": 0.0001, + "sup_loss": 1.4223957784583583 + }, + { + "step": 1556, + "lr": 0.0001, + "sup_loss": 1.407259798366072 + }, + { + "step": 1557, + "lr": 0.0001, + "sup_loss": 1.4089124678735199 + }, + { + "step": 1558, + "lr": 0.0001, + "sup_loss": 1.4491187104295231 + }, + { + "step": 1559, + "lr": 0.0001, + "sup_loss": 1.426229774829771 + }, + { + "step": 1560, + "lr": 0.0001, + "sup_loss": 1.4511797323531495 + }, + { + "step": 1561, + "lr": 0.0001, + "sup_loss": 1.4345490973707553 + }, + { + "step": 1562, + "lr": 0.0001, + "sup_loss": 1.423930644907223 + }, + { + "step": 1563, + "lr": 0.0001, + "sup_loss": 1.4115715099886488 + }, + { + "step": 1564, + "lr": 0.0001, + "sup_loss": 1.4624286309927732 + }, + { + "step": 1565, + "lr": 0.0001, + "sup_loss": 1.4377162691176748 + }, + { + "step": 1566, + "lr": 0.0001, + "sup_loss": 1.472821141684176 + }, + { + "step": 1567, + "lr": 0.0001, + "sup_loss": 1.441649061626242 + }, + { + "step": 1568, + "lr": 0.0001, + "sup_loss": 1.4046182423761906 + }, + { + "step": 1569, + "lr": 0.0001, + "sup_loss": 1.4447464080357837 + }, + { + "step": 1570, + "lr": 0.0001, + "sup_loss": 1.4435588230092717 + }, + { + "step": 1571, + "lr": 0.0001, + "sup_loss": 1.4307417489848482 + }, + { + "step": 1572, + "lr": 0.0001, + "sup_loss": 1.3650688021631034 + }, + { + "step": 1573, + "lr": 0.0001, + "sup_loss": 1.452389155388695 + }, + { + "step": 1574, + "lr": 0.0001, + "sup_loss": 1.435506967538476 + }, + { + "step": 1575, + "lr": 0.0001, + "sup_loss": 1.396915401950261 + }, + { + "step": 1576, + "lr": 0.0001, + "sup_loss": 1.4191532717079836 + }, + { + "step": 1577, + "lr": 0.0001, + "sup_loss": 1.4291236792398887 + }, + { + "step": 1578, + "lr": 0.0001, + "sup_loss": 1.4428497107445395 + }, + { + "step": 1579, + "lr": 0.0001, + "sup_loss": 1.4365638826806746 + }, + { + "step": 1580, + "lr": 0.0001, + "sup_loss": 1.4386359737369656 + }, + { + "step": 1581, + "lr": 0.0001, + "sup_loss": 1.4293804073971739 + }, + { + "step": 1582, + "lr": 0.0001, + "sup_loss": 1.4037636622759355 + }, + { + "step": 1583, + "lr": 0.0001, + "sup_loss": 1.4493564261489453 + }, + { + "step": 1584, + "lr": 0.0001, + "sup_loss": 1.425427620195918 + }, + { + "step": 1585, + "lr": 0.0001, + "sup_loss": 1.4265061881917855 + }, + { + "step": 1586, + "lr": 0.0001, + "sup_loss": 1.4494213139709435 + }, + { + "step": 1587, + "lr": 0.0001, + "sup_loss": 1.4289017183547863 + }, + { + "step": 1588, + "lr": 0.0001, + "sup_loss": 1.4320519049613913 + }, + { + "step": 1589, + "lr": 0.0001, + "sup_loss": 1.4315669939151838 + }, + { + "step": 1590, + "lr": 0.0001, + "sup_loss": 1.4432898052203689 + }, + { + "step": 1591, + "lr": 0.0001, + "sup_loss": 1.4061406292705643 + }, + { + "step": 1592, + "lr": 0.0001, + "sup_loss": 1.4313613710222521 + }, + { + "step": 1593, + "lr": 0.0001, + "sup_loss": 1.4197792724377134 + }, + { + "step": 1594, + "lr": 0.0001, + "sup_loss": 1.442038832529003 + }, + { + "step": 1595, + "lr": 0.0001, + "sup_loss": 1.378936526715241 + }, + { + "step": 1596, + "lr": 0.0001, + "sup_loss": 1.4292915904783534 + }, + { + "step": 1597, + "lr": 0.0001, + "sup_loss": 1.4338699193250708 + }, + { + "step": 1598, + "lr": 0.0001, + "sup_loss": 1.4062768140680455 + }, + { + "step": 1599, + "lr": 0.0001, + "sup_loss": 1.4390196676438947 + }, + { + "step": 1600, + "lr": 0.0001, + "sup_loss": 1.4286613750137396, + "lyap1_mean": -4.763199806213379, + "lyap1_max": -4.703543663024902, + "lyap_spec_mean": [ + -4.763199806213379, + -4.740202903747559 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1601, + "lr": 0.0001, + "sup_loss": 1.4313711013301813 + }, + { + "step": 1602, + "lr": 0.0001, + "sup_loss": 1.4231260501591987 + }, + { + "step": 1603, + "lr": 0.0001, + "sup_loss": 1.4143425399117926 + }, + { + "step": 1604, + "lr": 0.0001, + "sup_loss": 1.3952967175769726 + }, + { + "step": 1605, + "lr": 0.0001, + "sup_loss": 1.3696814367291628 + }, + { + "step": 1606, + "lr": 0.0001, + "sup_loss": 1.4499061611564183 + }, + { + "step": 1607, + "lr": 0.0001, + "sup_loss": 1.4623163085656987 + }, + { + "step": 1608, + "lr": 0.0001, + "sup_loss": 1.444351381271383 + }, + { + "step": 1609, + "lr": 0.0001, + "sup_loss": 1.481332893135834 + }, + { + "step": 1610, + "lr": 0.0001, + "sup_loss": 1.3963978987054417 + }, + { + "step": 1611, + "lr": 0.0001, + "sup_loss": 1.4446230649070155 + }, + { + "step": 1612, + "lr": 0.0001, + "sup_loss": 1.3832560736108355 + }, + { + "step": 1613, + "lr": 0.0001, + "sup_loss": 1.394415893257476 + }, + { + "step": 1614, + "lr": 0.0001, + "sup_loss": 1.398991654114705 + }, + { + "step": 1615, + "lr": 0.0001, + "sup_loss": 1.4276028124944597 + }, + { + "step": 1616, + "lr": 0.0001, + "sup_loss": 1.468078326701278 + }, + { + "step": 1617, + "lr": 0.0001, + "sup_loss": 1.430733044913817 + }, + { + "step": 1618, + "lr": 0.0001, + "sup_loss": 1.4431687698911906 + }, + { + "step": 1619, + "lr": 0.0001, + "sup_loss": 1.4145730132125411 + }, + { + "step": 1620, + "lr": 0.0001, + "sup_loss": 1.4416061158792244 + }, + { + "step": 1621, + "lr": 0.0001, + "sup_loss": 1.4485650497508529 + }, + { + "step": 1622, + "lr": 0.0001, + "sup_loss": 1.4362126962339543 + }, + { + "step": 1623, + "lr": 0.0001, + "sup_loss": 1.416302843311267 + }, + { + "step": 1624, + "lr": 0.0001, + "sup_loss": 1.3833771715083552 + }, + { + "step": 1625, + "lr": 0.0001, + "sup_loss": 1.4380014476274923 + }, + { + "step": 1626, + "lr": 0.0001, + "sup_loss": 1.393176127322929 + }, + { + "step": 1627, + "lr": 0.0001, + "sup_loss": 1.4463411928478747 + }, + { + "step": 1628, + "lr": 0.0001, + "sup_loss": 1.4824992297043507 + }, + { + "step": 1629, + "lr": 0.0001, + "sup_loss": 1.4585442526448107 + }, + { + "step": 1630, + "lr": 0.0001, + "sup_loss": 1.4582178907285923 + }, + { + "step": 1631, + "lr": 0.0001, + "sup_loss": 1.4075550806801504 + }, + { + "step": 1632, + "lr": 0.0001, + "sup_loss": 1.463687383620692 + }, + { + "step": 1633, + "lr": 0.0001, + "sup_loss": 1.3850792501614422 + }, + { + "step": 1634, + "lr": 0.0001, + "sup_loss": 1.4332836650862533 + }, + { + "step": 1635, + "lr": 0.0001, + "sup_loss": 1.4435765539443548 + }, + { + "step": 1636, + "lr": 0.0001, + "sup_loss": 1.4205704543582052 + }, + { + "step": 1637, + "lr": 0.0001, + "sup_loss": 1.4226421267757798 + }, + { + "step": 1638, + "lr": 0.0001, + "sup_loss": 1.3954355525190534 + }, + { + "step": 1639, + "lr": 0.0001, + "sup_loss": 1.4155729674883952 + }, + { + "step": 1640, + "lr": 0.0001, + "sup_loss": 1.418942643449481 + }, + { + "step": 1641, + "lr": 0.0001, + "sup_loss": 1.4405763550971713 + }, + { + "step": 1642, + "lr": 0.0001, + "sup_loss": 1.453842294406012 + }, + { + "step": 1643, + "lr": 0.0001, + "sup_loss": 1.4032510063544934 + }, + { + "step": 1644, + "lr": 0.0001, + "sup_loss": 1.4366442090870355 + }, + { + "step": 1645, + "lr": 0.0001, + "sup_loss": 1.4142527229832684 + }, + { + "step": 1646, + "lr": 0.0001, + "sup_loss": 1.4597409504314474 + }, + { + "step": 1647, + "lr": 0.0001, + "sup_loss": 1.390053620372242 + }, + { + "step": 1648, + "lr": 0.0001, + "sup_loss": 1.4452855452649864 + }, + { + "step": 1649, + "lr": 0.0001, + "sup_loss": 1.3482241767899956 + }, + { + "step": 1650, + "lr": 0.0001, + "sup_loss": 1.4379065717912682, + "lyap1_mean": -4.727723121643066, + "lyap1_max": -4.705477237701416, + "lyap_spec_mean": [ + -4.727723121643066, + -4.718955993652344 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1651, + "lr": 0.0001, + "sup_loss": 1.4321117705376714 + }, + { + "step": 1652, + "lr": 0.0001, + "sup_loss": 1.4133861409512296 + }, + { + "step": 1653, + "lr": 0.0001, + "sup_loss": 1.4176743542731363 + }, + { + "step": 1654, + "lr": 0.0001, + "sup_loss": 1.396138023143566 + }, + { + "step": 1655, + "lr": 0.0001, + "sup_loss": 1.3997407080845763 + }, + { + "step": 1656, + "lr": 0.0001, + "sup_loss": 1.427349155133362 + }, + { + "step": 1657, + "lr": 0.0001, + "sup_loss": 1.4258199824411828 + }, + { + "step": 1658, + "lr": 0.0001, + "sup_loss": 1.3965682996272144 + }, + { + "step": 1659, + "lr": 0.0001, + "sup_loss": 1.41996267365519 + }, + { + "step": 1660, + "lr": 0.0001, + "sup_loss": 1.384334905027236 + }, + { + "step": 1661, + "lr": 0.0001, + "sup_loss": 1.4192923429379514 + }, + { + "step": 1662, + "lr": 0.0001, + "sup_loss": 1.441896717427595 + }, + { + "step": 1663, + "lr": 0.0001, + "sup_loss": 1.4611603278310235 + }, + { + "step": 1664, + "lr": 0.0001, + "sup_loss": 1.4353512791182002 + }, + { + "step": 1665, + "lr": 0.0001, + "sup_loss": 1.4400298026306764 + }, + { + "step": 1666, + "lr": 0.0001, + "sup_loss": 1.4343377325640425 + }, + { + "step": 1667, + "lr": 0.0001, + "sup_loss": 1.339260407673035 + }, + { + "step": 1668, + "lr": 0.0001, + "sup_loss": 1.4315497336457232 + }, + { + "step": 1669, + "lr": 0.0001, + "sup_loss": 1.3972973322769555 + }, + { + "step": 1670, + "lr": 0.0001, + "sup_loss": 1.447709409675841 + }, + { + "step": 1671, + "lr": 0.0001, + "sup_loss": 1.463115475220204 + }, + { + "step": 1672, + "lr": 0.0001, + "sup_loss": 1.4403629075924735 + }, + { + "step": 1673, + "lr": 0.0001, + "sup_loss": 1.4281720894559717 + }, + { + "step": 1674, + "lr": 0.0001, + "sup_loss": 1.428105523848226 + }, + { + "step": 1675, + "lr": 0.0001, + "sup_loss": 1.3686610951756117 + }, + { + "step": 1676, + "lr": 0.0001, + "sup_loss": 1.4167514372908827 + }, + { + "step": 1677, + "lr": 0.0001, + "sup_loss": 1.3994320602767463 + }, + { + "step": 1678, + "lr": 0.0001, + "sup_loss": 1.4253372446178374 + }, + { + "step": 1679, + "lr": 0.0001, + "sup_loss": 1.4026265897817207 + }, + { + "step": 1680, + "lr": 0.0001, + "sup_loss": 1.3920230830007527 + }, + { + "step": 1681, + "lr": 0.0001, + "sup_loss": 1.4095924991565152 + }, + { + "step": 1682, + "lr": 0.0001, + "sup_loss": 1.4676702581083167 + }, + { + "step": 1683, + "lr": 0.0001, + "sup_loss": 1.3992303969655753 + }, + { + "step": 1684, + "lr": 0.0001, + "sup_loss": 1.4439143679373132 + }, + { + "step": 1685, + "lr": 0.0001, + "sup_loss": 1.4034484221378796 + }, + { + "step": 1686, + "lr": 0.0001, + "sup_loss": 1.418778198822478 + }, + { + "step": 1687, + "lr": 0.0001, + "sup_loss": 1.4083344627812966 + }, + { + "step": 1688, + "lr": 0.0001, + "sup_loss": 1.4120106667129981 + }, + { + "step": 1689, + "lr": 0.0001, + "sup_loss": 1.3977457566406022 + }, + { + "step": 1690, + "lr": 0.0001, + "sup_loss": 1.422282104114155 + }, + { + "step": 1691, + "lr": 0.0001, + "sup_loss": 1.4226098030955077 + }, + { + "step": 1692, + "lr": 0.0001, + "sup_loss": 1.4197586173031582 + }, + { + "step": 1693, + "lr": 0.0001, + "sup_loss": 1.4018677006490612 + }, + { + "step": 1694, + "lr": 0.0001, + "sup_loss": 1.4733926593923452 + }, + { + "step": 1695, + "lr": 0.0001, + "sup_loss": 1.4167489364297425 + }, + { + "step": 1696, + "lr": 0.0001, + "sup_loss": 1.43865931643097 + }, + { + "step": 1697, + "lr": 0.0001, + "sup_loss": 1.4411628795526243 + }, + { + "step": 1698, + "lr": 0.0001, + "sup_loss": 1.4263331180858603 + }, + { + "step": 1699, + "lr": 0.0001, + "sup_loss": 1.41919149827389 + }, + { + "step": 1700, + "lr": 0.0001, + "sup_loss": 1.4295963893504244, + "lyap1_mean": -4.666998386383057, + "lyap1_max": -4.567479610443115, + "lyap_spec_mean": [ + -4.666998386383057, + -4.687930107116699 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1701, + "lr": 0.0001, + "sup_loss": 1.368808215756502 + }, + { + "step": 1702, + "lr": 0.0001, + "sup_loss": 1.4008436537421505 + }, + { + "step": 1703, + "lr": 0.0001, + "sup_loss": 1.4424056708332293 + }, + { + "step": 1704, + "lr": 0.0001, + "sup_loss": 1.4039474706585189 + }, + { + "step": 1705, + "lr": 0.0001, + "sup_loss": 1.3633327161587419 + }, + { + "step": 1706, + "lr": 0.0001, + "sup_loss": 1.4025609839473128 + }, + { + "step": 1707, + "lr": 0.0001, + "sup_loss": 1.4483348634165458 + }, + { + "step": 1708, + "lr": 0.0001, + "sup_loss": 1.3753938609075513 + }, + { + "step": 1709, + "lr": 0.0001, + "sup_loss": 1.4157479029280444 + }, + { + "step": 1710, + "lr": 0.0001, + "sup_loss": 1.4666936377813222 + }, + { + "step": 1711, + "lr": 0.0001, + "sup_loss": 1.4452608477161177 + }, + { + "step": 1712, + "lr": 0.0001, + "sup_loss": 1.3974868662753643 + }, + { + "step": 1713, + "lr": 0.0001, + "sup_loss": 1.4255705364106201 + }, + { + "step": 1714, + "lr": 0.0001, + "sup_loss": 1.4152061894028702 + }, + { + "step": 1715, + "lr": 0.0001, + "sup_loss": 1.4241624227422516 + }, + { + "step": 1716, + "lr": 0.0001, + "sup_loss": 1.4129704169481392 + }, + { + "step": 1717, + "lr": 0.0001, + "sup_loss": 1.4026697305936924 + }, + { + "step": 1718, + "lr": 0.0001, + "sup_loss": 1.423574577463633 + }, + { + "step": 1719, + "lr": 0.0001, + "sup_loss": 1.4466356305993462 + }, + { + "step": 1720, + "lr": 0.0001, + "sup_loss": 1.4175193956136638 + }, + { + "step": 1721, + "lr": 0.0001, + "sup_loss": 1.4164095825015055 + }, + { + "step": 1722, + "lr": 0.0001, + "sup_loss": 1.4511173858479929 + }, + { + "step": 1723, + "lr": 0.0001, + "sup_loss": 1.400809494659548 + }, + { + "step": 1724, + "lr": 0.0001, + "sup_loss": 1.3742221062609383 + }, + { + "step": 1725, + "lr": 0.0001, + "sup_loss": 1.391124666874474 + }, + { + "step": 1726, + "lr": 0.0001, + "sup_loss": 1.433945069819226 + }, + { + "step": 1727, + "lr": 0.0001, + "sup_loss": 1.418308873193478 + }, + { + "step": 1728, + "lr": 0.0001, + "sup_loss": 1.390428470826234 + }, + { + "step": 1729, + "lr": 0.0001, + "sup_loss": 1.3973969970307558 + }, + { + "step": 1730, + "lr": 0.0001, + "sup_loss": 1.3900446181179833 + }, + { + "step": 1731, + "lr": 0.0001, + "sup_loss": 1.4597287572458324 + }, + { + "step": 1732, + "lr": 0.0001, + "sup_loss": 1.393457958165169 + }, + { + "step": 1733, + "lr": 0.0001, + "sup_loss": 1.381019286796775 + }, + { + "step": 1734, + "lr": 0.0001, + "sup_loss": 1.4181985526336014 + }, + { + "step": 1735, + "lr": 0.0001, + "sup_loss": 1.453825708510764 + }, + { + "step": 1736, + "lr": 0.0001, + "sup_loss": 1.4172176895689348 + }, + { + "step": 1737, + "lr": 0.0001, + "sup_loss": 1.3895565057409323 + }, + { + "step": 1738, + "lr": 0.0001, + "sup_loss": 1.3937831329283283 + }, + { + "step": 1739, + "lr": 0.0001, + "sup_loss": 1.4367301391783125 + }, + { + "step": 1740, + "lr": 0.0001, + "sup_loss": 1.3726961230187977 + }, + { + "step": 1741, + "lr": 0.0001, + "sup_loss": 1.3119534294457615 + }, + { + "step": 1742, + "lr": 0.0001, + "sup_loss": 1.3920696637967949 + }, + { + "step": 1743, + "lr": 0.0001, + "sup_loss": 1.4287212232165254 + }, + { + "step": 1744, + "lr": 0.0001, + "sup_loss": 1.3921783234162188 + }, + { + "step": 1745, + "lr": 0.0001, + "sup_loss": 1.4124704721235282 + }, + { + "step": 1746, + "lr": 0.0001, + "sup_loss": 1.399998407494116 + }, + { + "step": 1747, + "lr": 0.0001, + "sup_loss": 1.383717333187172 + }, + { + "step": 1748, + "lr": 0.0001, + "sup_loss": 1.4199211011343578 + }, + { + "step": 1749, + "lr": 0.0001, + "sup_loss": 1.4110596219218836 + }, + { + "step": 1750, + "lr": 0.0001, + "sup_loss": 1.3852943158751683, + "lyap1_mean": -4.665495872497559, + "lyap1_max": -4.607874870300293, + "lyap_spec_mean": [ + -4.665495872497559, + -4.658141613006592 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1751, + "lr": 0.0001, + "sup_loss": 1.4154354821456574 + }, + { + "step": 1752, + "lr": 0.0001, + "sup_loss": 1.4172083339262436 + }, + { + "step": 1753, + "lr": 0.0001, + "sup_loss": 1.4135405345450556 + }, + { + "step": 1754, + "lr": 0.0001, + "sup_loss": 1.379603965541869 + }, + { + "step": 1755, + "lr": 0.0001, + "sup_loss": 1.3878612968546624 + }, + { + "step": 1756, + "lr": 0.0001, + "sup_loss": 1.4169794308392718 + }, + { + "step": 1757, + "lr": 0.0001, + "sup_loss": 1.390763599809836 + }, + { + "step": 1758, + "lr": 0.0001, + "sup_loss": 1.404710588437579 + }, + { + "step": 1759, + "lr": 0.0001, + "sup_loss": 1.3681668535604654 + }, + { + "step": 1760, + "lr": 0.0001, + "sup_loss": 1.3634273104455894 + }, + { + "step": 1761, + "lr": 0.0001, + "sup_loss": 1.404242511108502 + }, + { + "step": 1762, + "lr": 0.0001, + "sup_loss": 1.3987200136279294 + }, + { + "step": 1763, + "lr": 0.0001, + "sup_loss": 1.3850970972823995 + }, + { + "step": 1764, + "lr": 0.0001, + "sup_loss": 1.4217052902258702 + }, + { + "step": 1765, + "lr": 0.0001, + "sup_loss": 1.3811997233220383 + }, + { + "step": 1766, + "lr": 0.0001, + "sup_loss": 1.385024861362425 + }, + { + "step": 1767, + "lr": 0.0001, + "sup_loss": 1.3981786536608454 + }, + { + "step": 1768, + "lr": 0.0001, + "sup_loss": 1.4028420398945523 + }, + { + "step": 1769, + "lr": 0.0001, + "sup_loss": 1.380682339552197 + }, + { + "step": 1770, + "lr": 0.0001, + "sup_loss": 1.3938850645461112 + }, + { + "step": 1771, + "lr": 0.0001, + "sup_loss": 1.363675775688171 + }, + { + "step": 1772, + "lr": 0.0001, + "sup_loss": 1.4344493868953614 + }, + { + "step": 1773, + "lr": 0.0001, + "sup_loss": 1.402734453717096 + }, + { + "step": 1774, + "lr": 0.0001, + "sup_loss": 1.3663507661756613 + }, + { + "step": 1775, + "lr": 0.0001, + "sup_loss": 1.4146546193642076 + }, + { + "step": 1776, + "lr": 0.0001, + "sup_loss": 1.4156933171663155 + }, + { + "step": 1777, + "lr": 0.0001, + "sup_loss": 1.4110230298621136 + }, + { + "step": 1778, + "lr": 0.0001, + "sup_loss": 1.4096749192534321 + }, + { + "step": 1779, + "lr": 0.0001, + "sup_loss": 1.3991252063761694 + }, + { + "step": 1780, + "lr": 0.0001, + "sup_loss": 1.405071876213828 + }, + { + "step": 1781, + "lr": 0.0001, + "sup_loss": 1.4219530273745287 + }, + { + "step": 1782, + "lr": 0.0001, + "sup_loss": 1.3915157016652242 + }, + { + "step": 1783, + "lr": 0.0001, + "sup_loss": 1.3362497782625802 + }, + { + "step": 1784, + "lr": 0.0001, + "sup_loss": 1.4000166314644689 + }, + { + "step": 1785, + "lr": 0.0001, + "sup_loss": 1.4572615126400756 + }, + { + "step": 1786, + "lr": 0.0001, + "sup_loss": 1.3976051043897242 + }, + { + "step": 1787, + "lr": 0.0001, + "sup_loss": 1.417975945208371 + }, + { + "step": 1788, + "lr": 0.0001, + "sup_loss": 1.358364193911282 + }, + { + "step": 1789, + "lr": 0.0001, + "sup_loss": 1.358574264083261 + }, + { + "step": 1790, + "lr": 0.0001, + "sup_loss": 1.3813598780221896 + }, + { + "step": 1791, + "lr": 0.0001, + "sup_loss": 1.4057036055515737 + }, + { + "step": 1792, + "lr": 0.0001, + "sup_loss": 1.3790889254336423 + }, + { + "step": 1793, + "lr": 0.0001, + "sup_loss": 1.4056022920146933 + }, + { + "step": 1794, + "lr": 0.0001, + "sup_loss": 1.3881851822661222 + }, + { + "step": 1795, + "lr": 0.0001, + "sup_loss": 1.424536986619044 + }, + { + "step": 1796, + "lr": 0.0001, + "sup_loss": 1.3979382553177466 + }, + { + "step": 1797, + "lr": 0.0001, + "sup_loss": 1.3859685073661732 + }, + { + "step": 1798, + "lr": 0.0001, + "sup_loss": 1.357773099034569 + }, + { + "step": 1799, + "lr": 0.0001, + "sup_loss": 1.3601298417933319 + }, + { + "step": 1800, + "lr": 0.0001, + "sup_loss": 1.4187908267431826, + "lyap1_mean": -4.62960958480835, + "lyap1_max": -4.570792198181152, + "lyap_spec_mean": [ + -4.62960958480835, + -4.651381492614746 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1801, + "lr": 0.0001, + "sup_loss": 1.3574161597477685 + }, + { + "step": 1802, + "lr": 0.0001, + "sup_loss": 1.355414399823228 + }, + { + "step": 1803, + "lr": 0.0001, + "sup_loss": 1.4024833809974402 + }, + { + "step": 1804, + "lr": 0.0001, + "sup_loss": 1.4281579382471437 + }, + { + "step": 1805, + "lr": 0.0001, + "sup_loss": 1.4105774814866274 + }, + { + "step": 1806, + "lr": 0.0001, + "sup_loss": 1.351410120821957 + }, + { + "step": 1807, + "lr": 0.0001, + "sup_loss": 1.3991370284857265 + }, + { + "step": 1808, + "lr": 0.0001, + "sup_loss": 1.396684954646597 + }, + { + "step": 1809, + "lr": 0.0001, + "sup_loss": 1.374611939318962 + }, + { + "step": 1810, + "lr": 0.0001, + "sup_loss": 1.4500494639353956 + }, + { + "step": 1811, + "lr": 0.0001, + "sup_loss": 1.4191725427228916 + }, + { + "step": 1812, + "lr": 0.0001, + "sup_loss": 1.3995994802422211 + }, + { + "step": 1813, + "lr": 0.0001, + "sup_loss": 1.410303378418079 + }, + { + "step": 1814, + "lr": 0.0001, + "sup_loss": 1.442840957922918 + }, + { + "step": 1815, + "lr": 0.0001, + "sup_loss": 1.423430399397906 + }, + { + "step": 1816, + "lr": 0.0001, + "sup_loss": 1.4162455501383775 + }, + { + "step": 1817, + "lr": 0.0001, + "sup_loss": 1.3957264635105329 + }, + { + "step": 1818, + "lr": 0.0001, + "sup_loss": 1.3883472385148203 + }, + { + "step": 1819, + "lr": 0.0001, + "sup_loss": 1.3986012840542092 + }, + { + "step": 1820, + "lr": 0.0001, + "sup_loss": 1.4149770767182999 + }, + { + "step": 1821, + "lr": 0.0001, + "sup_loss": 1.4158087284454697 + }, + { + "step": 1822, + "lr": 0.0001, + "sup_loss": 1.34151407297393 + }, + { + "step": 1823, + "lr": 0.0001, + "sup_loss": 1.429926544348806 + }, + { + "step": 1824, + "lr": 0.0001, + "sup_loss": 1.3765306548971357 + }, + { + "step": 1825, + "lr": 0.0001, + "sup_loss": 1.3793901430864282 + }, + { + "step": 1826, + "lr": 0.0001, + "sup_loss": 1.4258960331562627 + }, + { + "step": 1827, + "lr": 0.0001, + "sup_loss": 1.375496475255633 + }, + { + "step": 1828, + "lr": 0.0001, + "sup_loss": 1.3961845866896458 + }, + { + "step": 1829, + "lr": 0.0001, + "sup_loss": 1.3705326303916847 + }, + { + "step": 1830, + "lr": 0.0001, + "sup_loss": 1.397554361593062 + }, + { + "step": 1831, + "lr": 0.0001, + "sup_loss": 1.373649047047743 + }, + { + "step": 1832, + "lr": 0.0001, + "sup_loss": 1.4103971124850156 + }, + { + "step": 1833, + "lr": 0.0001, + "sup_loss": 1.3926332421959795 + }, + { + "step": 1834, + "lr": 0.0001, + "sup_loss": 1.3545180573066256 + }, + { + "step": 1835, + "lr": 0.0001, + "sup_loss": 1.372013159211798 + }, + { + "step": 1836, + "lr": 0.0001, + "sup_loss": 1.3798558807830417 + }, + { + "step": 1837, + "lr": 0.0001, + "sup_loss": 1.383717975292924 + }, + { + "step": 1838, + "lr": 0.0001, + "sup_loss": 1.4071825646725735 + }, + { + "step": 1839, + "lr": 0.0001, + "sup_loss": 1.3979549619438212 + }, + { + "step": 1840, + "lr": 0.0001, + "sup_loss": 1.4056753356756657 + }, + { + "step": 1841, + "lr": 0.0001, + "sup_loss": 1.4127502290037786 + }, + { + "step": 1842, + "lr": 0.0001, + "sup_loss": 1.3886539086301197 + }, + { + "step": 1843, + "lr": 0.0001, + "sup_loss": 1.4014478585827812 + }, + { + "step": 1844, + "lr": 0.0001, + "sup_loss": 1.3542597916264838 + }, + { + "step": 1845, + "lr": 0.0001, + "sup_loss": 1.4282028043211747 + }, + { + "step": 1846, + "lr": 0.0001, + "sup_loss": 1.370276096968387 + }, + { + "step": 1847, + "lr": 0.0001, + "sup_loss": 1.341062965962153 + }, + { + "step": 1848, + "lr": 0.0001, + "sup_loss": 1.3682682882270654 + }, + { + "step": 1849, + "lr": 0.0001, + "sup_loss": 1.428371940704332 + }, + { + "step": 1850, + "lr": 0.0001, + "sup_loss": 1.3711423610060844, + "lyap1_mean": -4.5718889236450195, + "lyap1_max": -4.5085368156433105, + "lyap_spec_mean": [ + -4.5718889236450195, + -4.579253196716309 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1851, + "lr": 0.0001, + "sup_loss": 1.348380735959665 + }, + { + "step": 1852, + "lr": 0.0001, + "sup_loss": 1.3986638988927877 + }, + { + "step": 1853, + "lr": 0.0001, + "sup_loss": 1.4137244831379143 + }, + { + "step": 1854, + "lr": 0.0001, + "sup_loss": 1.4296081719085751 + }, + { + "step": 1855, + "lr": 0.0001, + "sup_loss": 1.371001389861114 + }, + { + "step": 1856, + "lr": 0.0001, + "sup_loss": 1.3773995933767789 + }, + { + "step": 1857, + "lr": 0.0001, + "sup_loss": 1.388658394430795 + }, + { + "step": 1858, + "lr": 0.0001, + "sup_loss": 1.4196961903670395 + }, + { + "step": 1859, + "lr": 0.0001, + "sup_loss": 1.3293056408568562 + }, + { + "step": 1860, + "lr": 0.0001, + "sup_loss": 1.399139365002204 + }, + { + "step": 1861, + "lr": 0.0001, + "sup_loss": 1.3670867419921997 + }, + { + "step": 1862, + "lr": 0.0001, + "sup_loss": 1.3892964577941027 + }, + { + "step": 1863, + "lr": 0.0001, + "sup_loss": 1.3572912979517981 + }, + { + "step": 1864, + "lr": 0.0001, + "sup_loss": 1.3664007912623206 + }, + { + "step": 1865, + "lr": 0.0001, + "sup_loss": 1.3731805600850344 + }, + { + "step": 1866, + "lr": 0.0001, + "sup_loss": 1.4258346218510285 + }, + { + "step": 1867, + "lr": 0.0001, + "sup_loss": 1.416389178871045 + }, + { + "step": 1868, + "lr": 0.0001, + "sup_loss": 1.348899805158484 + }, + { + "step": 1869, + "lr": 0.0001, + "sup_loss": 1.4312741790962196 + }, + { + "step": 1870, + "lr": 0.0001, + "sup_loss": 1.3691486633477414 + }, + { + "step": 1871, + "lr": 0.0001, + "sup_loss": 1.2970178135696564 + }, + { + "step": 1872, + "lr": 0.0001, + "sup_loss": 1.3593750928806394 + }, + { + "step": 1873, + "lr": 0.0001, + "sup_loss": 1.3980547495966205 + }, + { + "step": 1874, + "lr": 0.0001, + "sup_loss": 1.3832893584152175 + }, + { + "step": 1875, + "lr": 0.0001, + "sup_loss": 1.3819986745020088 + }, + { + "step": 1876, + "lr": 0.0001, + "sup_loss": 1.351680373549221 + }, + { + "step": 1877, + "lr": 0.0001, + "sup_loss": 1.3691332268933585 + }, + { + "step": 1878, + "lr": 0.0001, + "sup_loss": 1.3921900335628232 + }, + { + "step": 1879, + "lr": 0.0001, + "sup_loss": 1.428229541835207 + }, + { + "step": 1880, + "lr": 0.0001, + "sup_loss": 1.4162603156116025 + }, + { + "step": 1881, + "lr": 0.0001, + "sup_loss": 1.3940852528683518 + }, + { + "step": 1882, + "lr": 0.0001, + "sup_loss": 1.400741486875141 + }, + { + "step": 1883, + "lr": 0.0001, + "sup_loss": 1.4076794064796443 + }, + { + "step": 1884, + "lr": 0.0001, + "sup_loss": 1.3663377710270712 + }, + { + "step": 1885, + "lr": 0.0001, + "sup_loss": 1.4084374549276877 + }, + { + "step": 1886, + "lr": 0.0001, + "sup_loss": 1.3710445340193365 + }, + { + "step": 1887, + "lr": 0.0001, + "sup_loss": 1.3391371076123924 + }, + { + "step": 1888, + "lr": 0.0001, + "sup_loss": 1.38349138572003 + }, + { + "step": 1889, + "lr": 0.0001, + "sup_loss": 1.376654163245699 + }, + { + "step": 1890, + "lr": 0.0001, + "sup_loss": 1.3542202794361082 + }, + { + "step": 1891, + "lr": 0.0001, + "sup_loss": 1.4102894048653727 + }, + { + "step": 1892, + "lr": 0.0001, + "sup_loss": 1.382272815501765 + }, + { + "step": 1893, + "lr": 0.0001, + "sup_loss": 1.370449816666093 + }, + { + "step": 1894, + "lr": 0.0001, + "sup_loss": 1.3641785166006943 + }, + { + "step": 1895, + "lr": 0.0001, + "sup_loss": 1.3873136818146585 + }, + { + "step": 1896, + "lr": 0.0001, + "sup_loss": 1.392690423088317 + }, + { + "step": 1897, + "lr": 0.0001, + "sup_loss": 1.3981610075934223 + }, + { + "step": 1898, + "lr": 0.0001, + "sup_loss": 1.3625417705878673 + }, + { + "step": 1899, + "lr": 0.0001, + "sup_loss": 1.4160414109306536 + }, + { + "step": 1900, + "lr": 0.0001, + "sup_loss": 1.4053043733147106, + "lyap1_mean": -4.53842830657959, + "lyap1_max": -4.492893218994141, + "lyap_spec_mean": [ + -4.53842830657959, + -4.5512495040893555 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1901, + "lr": 0.0001, + "sup_loss": 1.4107048570158751 + }, + { + "step": 1902, + "lr": 0.0001, + "sup_loss": 1.3964958672363343 + }, + { + "step": 1903, + "lr": 0.0001, + "sup_loss": 1.3556434403984523 + }, + { + "step": 1904, + "lr": 0.0001, + "sup_loss": 1.4003847344722227 + }, + { + "step": 1905, + "lr": 0.0001, + "sup_loss": 1.3701481630931416 + }, + { + "step": 1906, + "lr": 0.0001, + "sup_loss": 1.4036731353597947 + }, + { + "step": 1907, + "lr": 0.0001, + "sup_loss": 1.3701097420037023 + }, + { + "step": 1908, + "lr": 0.0001, + "sup_loss": 1.3820651570078104 + }, + { + "step": 1909, + "lr": 0.0001, + "sup_loss": 1.351438467875153 + }, + { + "step": 1910, + "lr": 0.0001, + "sup_loss": 1.3710336553706137 + }, + { + "step": 1911, + "lr": 0.0001, + "sup_loss": 1.404502492106915 + }, + { + "step": 1912, + "lr": 0.0001, + "sup_loss": 1.349230291289015 + }, + { + "step": 1913, + "lr": 0.0001, + "sup_loss": 1.3736967708773877 + }, + { + "step": 1914, + "lr": 0.0001, + "sup_loss": 1.3658889705251354 + }, + { + "step": 1915, + "lr": 0.0001, + "sup_loss": 1.3860899697779687 + }, + { + "step": 1916, + "lr": 0.0001, + "sup_loss": 1.4095423822978685 + }, + { + "step": 1917, + "lr": 0.0001, + "sup_loss": 1.3913746743084574 + }, + { + "step": 1918, + "lr": 0.0001, + "sup_loss": 1.3960645178836417 + }, + { + "step": 1919, + "lr": 0.0001, + "sup_loss": 1.428211219191195 + }, + { + "step": 1920, + "lr": 0.0001, + "sup_loss": 1.35381152076921 + }, + { + "step": 1921, + "lr": 0.0001, + "sup_loss": 1.385247152655118 + }, + { + "step": 1922, + "lr": 0.0001, + "sup_loss": 1.384072328326964 + }, + { + "step": 1923, + "lr": 0.0001, + "sup_loss": 1.390136799768782 + }, + { + "step": 1924, + "lr": 0.0001, + "sup_loss": 1.3208568632871849 + }, + { + "step": 1925, + "lr": 0.0001, + "sup_loss": 1.3798523590951521 + }, + { + "step": 1926, + "lr": 0.0001, + "sup_loss": 1.4030636325146573 + }, + { + "step": 1927, + "lr": 0.0001, + "sup_loss": 1.3849178670786395 + }, + { + "step": 1928, + "lr": 0.0001, + "sup_loss": 1.3421631008540733 + }, + { + "step": 1929, + "lr": 0.0001, + "sup_loss": 1.3928845883950856 + }, + { + "step": 1930, + "lr": 0.0001, + "sup_loss": 1.4034779927886587 + }, + { + "step": 1931, + "lr": 0.0001, + "sup_loss": 1.3333934110961831 + }, + { + "step": 1932, + "lr": 0.0001, + "sup_loss": 1.398043299923857 + }, + { + "step": 1933, + "lr": 0.0001, + "sup_loss": 1.3400236050026983 + }, + { + "step": 1934, + "lr": 0.0001, + "sup_loss": 1.3553997056338085 + }, + { + "step": 1935, + "lr": 0.0001, + "sup_loss": 1.390199603919459 + }, + { + "step": 1936, + "lr": 0.0001, + "sup_loss": 1.347300077002741 + }, + { + "step": 1937, + "lr": 0.0001, + "sup_loss": 1.3652634305398639 + }, + { + "step": 1938, + "lr": 0.0001, + "sup_loss": 1.3636650235783987 + }, + { + "step": 1939, + "lr": 0.0001, + "sup_loss": 1.3530957622303976 + }, + { + "step": 1940, + "lr": 0.0001, + "sup_loss": 1.3438039199411747 + }, + { + "step": 1941, + "lr": 0.0001, + "sup_loss": 1.3657952402072888 + }, + { + "step": 1942, + "lr": 0.0001, + "sup_loss": 1.3590142963982565 + }, + { + "step": 1943, + "lr": 0.0001, + "sup_loss": 1.3876171940240831 + }, + { + "step": 1944, + "lr": 0.0001, + "sup_loss": 1.3701369302199544 + }, + { + "step": 1945, + "lr": 0.0001, + "sup_loss": 1.338177333367471 + }, + { + "step": 1946, + "lr": 0.0001, + "sup_loss": 1.3602897982810362 + }, + { + "step": 1947, + "lr": 0.0001, + "sup_loss": 1.384471648891986 + }, + { + "step": 1948, + "lr": 0.0001, + "sup_loss": 1.3604608414742663 + }, + { + "step": 1949, + "lr": 0.0001, + "sup_loss": 1.3703963081130108 + }, + { + "step": 1950, + "lr": 0.0001, + "sup_loss": 1.4018406171793427, + "lyap1_mean": -4.516169548034668, + "lyap1_max": -4.479403972625732, + "lyap_spec_mean": [ + -4.516169548034668, + -4.495737075805664 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1951, + "lr": 0.0001, + "sup_loss": 1.3500330270163146 + }, + { + "step": 1952, + "lr": 0.0001, + "sup_loss": 1.363580224458456 + }, + { + "step": 1953, + "lr": 0.0001, + "sup_loss": 1.3825467728430256 + }, + { + "step": 1954, + "lr": 0.0001, + "sup_loss": 1.3764015580633722 + }, + { + "step": 1955, + "lr": 0.0001, + "sup_loss": 1.3986757844247562 + }, + { + "step": 1956, + "lr": 0.0001, + "sup_loss": 1.3747816825360306 + }, + { + "step": 1957, + "lr": 0.0001, + "sup_loss": 1.4085027575932358 + }, + { + "step": 1958, + "lr": 0.0001, + "sup_loss": 1.3716618639585965 + }, + { + "step": 1959, + "lr": 0.0001, + "sup_loss": 1.3661716399809094 + }, + { + "step": 1960, + "lr": 0.0001, + "sup_loss": 1.3768941721439172 + }, + { + "step": 1961, + "lr": 0.0001, + "sup_loss": 1.3784926722056297 + }, + { + "step": 1962, + "lr": 0.0001, + "sup_loss": 1.3340065422054161 + }, + { + "step": 1963, + "lr": 0.0001, + "sup_loss": 1.3227949248290736 + }, + { + "step": 1964, + "lr": 0.0001, + "sup_loss": 1.3929235162318456 + }, + { + "step": 1965, + "lr": 0.0001, + "sup_loss": 1.3218183026505725 + }, + { + "step": 1966, + "lr": 0.0001, + "sup_loss": 1.444029727840847 + }, + { + "step": 1967, + "lr": 0.0001, + "sup_loss": 1.4018837207395192 + }, + { + "step": 1968, + "lr": 0.0001, + "sup_loss": 1.3633056906174885 + }, + { + "step": 1969, + "lr": 0.0001, + "sup_loss": 1.3967052206371235 + }, + { + "step": 1970, + "lr": 0.0001, + "sup_loss": 1.3751573463676405 + }, + { + "step": 1971, + "lr": 0.0001, + "sup_loss": 1.4010431141358848 + }, + { + "step": 1972, + "lr": 0.0001, + "sup_loss": 1.3643291837044647 + }, + { + "step": 1973, + "lr": 0.0001, + "sup_loss": 1.343893317074618 + }, + { + "step": 1974, + "lr": 0.0001, + "sup_loss": 1.363457349721676 + }, + { + "step": 1975, + "lr": 0.0001, + "sup_loss": 1.3949115992663166 + }, + { + "step": 1976, + "lr": 0.0001, + "sup_loss": 1.3893924954110135 + }, + { + "step": 1977, + "lr": 0.0001, + "sup_loss": 1.4092470410492952 + }, + { + "step": 1978, + "lr": 0.0001, + "sup_loss": 1.3345610672982104 + }, + { + "step": 1979, + "lr": 0.0001, + "sup_loss": 1.3902674244951962 + }, + { + "step": 1980, + "lr": 0.0001, + "sup_loss": 1.4075058165576269 + }, + { + "step": 1981, + "lr": 0.0001, + "sup_loss": 1.3316610519409164 + }, + { + "step": 1982, + "lr": 0.0001, + "sup_loss": 1.4125409922811145 + }, + { + "step": 1983, + "lr": 0.0001, + "sup_loss": 1.3095982795860546 + }, + { + "step": 1984, + "lr": 0.0001, + "sup_loss": 1.3758205076958196 + }, + { + "step": 1985, + "lr": 0.0001, + "sup_loss": 1.3452453134603115 + }, + { + "step": 1986, + "lr": 0.0001, + "sup_loss": 1.3753948695071716 + }, + { + "step": 1987, + "lr": 0.0001, + "sup_loss": 1.377792582050537 + }, + { + "step": 1988, + "lr": 0.0001, + "sup_loss": 1.3718805125867044 + }, + { + "step": 1989, + "lr": 0.0001, + "sup_loss": 1.3778118905184646 + }, + { + "step": 1990, + "lr": 0.0001, + "sup_loss": 1.3293731493176637 + }, + { + "step": 1991, + "lr": 0.0001, + "sup_loss": 1.4046274258849833 + }, + { + "step": 1992, + "lr": 0.0001, + "sup_loss": 1.4007280834306206 + }, + { + "step": 1993, + "lr": 0.0001, + "sup_loss": 1.3563045856835036 + }, + { + "step": 1994, + "lr": 0.0001, + "sup_loss": 1.3696906464910985 + }, + { + "step": 1995, + "lr": 0.0001, + "sup_loss": 1.36281491055303 + }, + { + "step": 1996, + "lr": 0.0001, + "sup_loss": 1.3837184897117962 + }, + { + "step": 1997, + "lr": 0.0001, + "sup_loss": 1.3544101406493183 + }, + { + "step": 1998, + "lr": 0.0001, + "sup_loss": 1.3298358982086458 + }, + { + "step": 1999, + "lr": 0.0001, + "sup_loss": 1.3730415539217413 + }, + { + "step": 2000, + "lr": 0.0001, + "sup_loss": 1.3339980567745424, + "lyap1_mean": -4.510406970977783, + "lyap1_max": -4.459565162658691, + "lyap_spec_mean": [ + -4.510406970977783, + -4.500662803649902 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2001, + "lr": 0.0001, + "sup_loss": 1.3371870354264936 + }, + { + "step": 2002, + "lr": 0.0001, + "sup_loss": 1.4213587230559992 + }, + { + "step": 2003, + "lr": 0.0001, + "sup_loss": 1.3779638016660272 + }, + { + "step": 2004, + "lr": 0.0001, + "sup_loss": 1.3608991042341083 + }, + { + "step": 2005, + "lr": 0.0001, + "sup_loss": 1.3399255695591843 + }, + { + "step": 2006, + "lr": 0.0001, + "sup_loss": 1.3752057915289775 + }, + { + "step": 2007, + "lr": 0.0001, + "sup_loss": 1.3577482652881274 + }, + { + "step": 2008, + "lr": 0.0001, + "sup_loss": 1.420962343146364 + }, + { + "step": 2009, + "lr": 0.0001, + "sup_loss": 1.3869896191585642 + }, + { + "step": 2010, + "lr": 0.0001, + "sup_loss": 1.3300569782640892 + }, + { + "step": 2011, + "lr": 0.0001, + "sup_loss": 1.3518849763589253 + }, + { + "step": 2012, + "lr": 0.0001, + "sup_loss": 1.3633507773214506 + }, + { + "step": 2013, + "lr": 0.0001, + "sup_loss": 1.3668917123030626 + }, + { + "step": 2014, + "lr": 0.0001, + "sup_loss": 1.2853489140843513 + }, + { + "step": 2015, + "lr": 0.0001, + "sup_loss": 1.3752328556622242 + }, + { + "step": 2016, + "lr": 0.0001, + "sup_loss": 1.3664280062232317 + }, + { + "step": 2017, + "lr": 0.0001, + "sup_loss": 1.3447542337864204 + }, + { + "step": 2018, + "lr": 0.0001, + "sup_loss": 1.401180823346046 + }, + { + "step": 2019, + "lr": 0.0001, + "sup_loss": 1.3402864764695757 + }, + { + "step": 2020, + "lr": 0.0001, + "sup_loss": 1.372260005720886 + }, + { + "step": 2021, + "lr": 0.0001, + "sup_loss": 1.3881757923395248 + }, + { + "step": 2022, + "lr": 0.0001, + "sup_loss": 1.359384677600057 + }, + { + "step": 2023, + "lr": 0.0001, + "sup_loss": 1.355233183048644 + }, + { + "step": 2024, + "lr": 0.0001, + "sup_loss": 1.3470691102570524 + }, + { + "step": 2025, + "lr": 0.0001, + "sup_loss": 1.4058171736607916 + }, + { + "step": 2026, + "lr": 0.0001, + "sup_loss": 1.356862271584181 + }, + { + "step": 2027, + "lr": 0.0001, + "sup_loss": 1.340608530338701 + }, + { + "step": 2028, + "lr": 0.0001, + "sup_loss": 1.3545155323893496 + }, + { + "step": 2029, + "lr": 0.0001, + "sup_loss": 1.3133003500655724 + }, + { + "step": 2030, + "lr": 0.0001, + "sup_loss": 1.3365171777295242 + }, + { + "step": 2031, + "lr": 0.0001, + "sup_loss": 1.3352465254532073 + }, + { + "step": 2032, + "lr": 0.0001, + "sup_loss": 1.3290639518194507 + }, + { + "step": 2033, + "lr": 0.0001, + "sup_loss": 1.3632602898580546 + }, + { + "step": 2034, + "lr": 0.0001, + "sup_loss": 1.3562538715277097 + }, + { + "step": 2035, + "lr": 0.0001, + "sup_loss": 1.3295290558729622 + }, + { + "step": 2036, + "lr": 0.0001, + "sup_loss": 1.322156576770507 + }, + { + "step": 2037, + "lr": 0.0001, + "sup_loss": 1.3888129229545707 + }, + { + "step": 2038, + "lr": 0.0001, + "sup_loss": 1.3752207107333982 + }, + { + "step": 2039, + "lr": 0.0001, + "sup_loss": 1.3446958521638506 + }, + { + "step": 2040, + "lr": 0.0001, + "sup_loss": 1.3366004534173135 + }, + { + "step": 2041, + "lr": 0.0001, + "sup_loss": 1.3467699518232084 + }, + { + "step": 2042, + "lr": 0.0001, + "sup_loss": 1.3656164575958503 + }, + { + "step": 2043, + "lr": 0.0001, + "sup_loss": 1.3585792298831325 + }, + { + "step": 2044, + "lr": 0.0001, + "sup_loss": 1.325510437750258 + }, + { + "step": 2045, + "lr": 0.0001, + "sup_loss": 1.3482649999496745 + }, + { + "step": 2046, + "lr": 0.0001, + "sup_loss": 1.3387166154589614 + }, + { + "step": 2047, + "lr": 0.0001, + "sup_loss": 1.3407015457823028 + }, + { + "step": 2048, + "lr": 0.0001, + "sup_loss": 1.3371180036322672 + }, + { + "step": 2049, + "lr": 0.0001, + "sup_loss": 1.340069140539834 + }, + { + "step": 2050, + "lr": 0.0001, + "sup_loss": 1.3547002810767044, + "lyap1_mean": -4.465114116668701, + "lyap1_max": -4.41412878036499, + "lyap_spec_mean": [ + -4.465114116668701, + -4.451486587524414 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2051, + "lr": 0.0001, + "sup_loss": 1.3396033592056957 + }, + { + "step": 2052, + "lr": 0.0001, + "sup_loss": 1.352171886298948 + }, + { + "step": 2053, + "lr": 0.0001, + "sup_loss": 1.3261017469531906 + }, + { + "step": 2054, + "lr": 0.0001, + "sup_loss": 1.3929580943568656 + }, + { + "step": 2055, + "lr": 0.0001, + "sup_loss": 1.3425537789890651 + }, + { + "step": 2056, + "lr": 0.0001, + "sup_loss": 1.3701583894130607 + }, + { + "step": 2057, + "lr": 0.0001, + "sup_loss": 1.3095096645410134 + }, + { + "step": 2058, + "lr": 0.0001, + "sup_loss": 1.3348805390814356 + }, + { + "step": 2059, + "lr": 0.0001, + "sup_loss": 1.3426512652266922 + }, + { + "step": 2060, + "lr": 0.0001, + "sup_loss": 1.3687856290577065 + }, + { + "step": 2061, + "lr": 0.0001, + "sup_loss": 1.3560780345011156 + }, + { + "step": 2062, + "lr": 0.0001, + "sup_loss": 1.3361326136446814 + }, + { + "step": 2063, + "lr": 0.0001, + "sup_loss": 1.366525492464688 + }, + { + "step": 2064, + "lr": 0.0001, + "sup_loss": 1.3551578869803815 + }, + { + "step": 2065, + "lr": 0.0001, + "sup_loss": 1.3209476441323327 + }, + { + "step": 2066, + "lr": 0.0001, + "sup_loss": 1.316228756887557 + }, + { + "step": 2067, + "lr": 0.0001, + "sup_loss": 1.3781661060899306 + }, + { + "step": 2068, + "lr": 0.0001, + "sup_loss": 1.3328621944853336 + }, + { + "step": 2069, + "lr": 0.0001, + "sup_loss": 1.3453852084449516 + }, + { + "step": 2070, + "lr": 0.0001, + "sup_loss": 1.329907436850029 + }, + { + "step": 2071, + "lr": 0.0001, + "sup_loss": 1.3992864140100056 + }, + { + "step": 2072, + "lr": 0.0001, + "sup_loss": 1.3695568559796663 + }, + { + "step": 2073, + "lr": 0.0001, + "sup_loss": 1.3698310707279227 + }, + { + "step": 2074, + "lr": 0.0001, + "sup_loss": 1.3681777200729452 + }, + { + "step": 2075, + "lr": 0.0001, + "sup_loss": 1.3069135426602005 + }, + { + "step": 2076, + "lr": 0.0001, + "sup_loss": 1.3980712289755775 + }, + { + "step": 2077, + "lr": 0.0001, + "sup_loss": 1.2731080181536578 + }, + { + "step": 2078, + "lr": 0.0001, + "sup_loss": 1.338121006075292 + }, + { + "step": 2079, + "lr": 0.0001, + "sup_loss": 1.3497756942480432 + }, + { + "step": 2080, + "lr": 0.0001, + "sup_loss": 1.4212349587276163 + }, + { + "step": 2081, + "lr": 0.0001, + "sup_loss": 1.3632858708765143 + }, + { + "step": 2082, + "lr": 0.0001, + "sup_loss": 1.365354353732921 + }, + { + "step": 2083, + "lr": 0.0001, + "sup_loss": 1.3493640688629125 + }, + { + "step": 2084, + "lr": 0.0001, + "sup_loss": 1.3673073397610955 + }, + { + "step": 2085, + "lr": 0.0001, + "sup_loss": 1.3180393474774583 + }, + { + "step": 2086, + "lr": 0.0001, + "sup_loss": 1.28029072671823 + }, + { + "step": 2087, + "lr": 0.0001, + "sup_loss": 1.3508910012541286 + }, + { + "step": 2088, + "lr": 0.0001, + "sup_loss": 1.335003578735963 + }, + { + "step": 2089, + "lr": 0.0001, + "sup_loss": 1.3512171262795194 + }, + { + "step": 2090, + "lr": 0.0001, + "sup_loss": 1.3447356327153654 + }, + { + "step": 2091, + "lr": 0.0001, + "sup_loss": 1.342019770746191 + }, + { + "step": 2092, + "lr": 0.0001, + "sup_loss": 1.3466366556492275 + }, + { + "step": 2093, + "lr": 0.0001, + "sup_loss": 1.3204282386642654 + }, + { + "step": 2094, + "lr": 0.0001, + "sup_loss": 1.3615720014134431 + }, + { + "step": 2095, + "lr": 0.0001, + "sup_loss": 1.3624110569628538 + }, + { + "step": 2096, + "lr": 0.0001, + "sup_loss": 1.3553442730115235 + }, + { + "step": 2097, + "lr": 0.0001, + "sup_loss": 1.3922013558258723 + }, + { + "step": 2098, + "lr": 0.0001, + "sup_loss": 1.3597693337119026 + }, + { + "step": 2099, + "lr": 0.0001, + "sup_loss": 1.3558919642597578 + }, + { + "step": 2100, + "lr": 0.0001, + "sup_loss": 1.3511568913760699, + "lyap1_mean": -4.426387310028076, + "lyap1_max": -4.368574142456055, + "lyap_spec_mean": [ + -4.426387786865234, + -4.434847831726074 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2101, + "lr": 0.0001, + "sup_loss": 1.3633861451477107 + }, + { + "step": 2102, + "lr": 0.0001, + "sup_loss": 1.3735655305801195 + }, + { + "step": 2103, + "lr": 0.0001, + "sup_loss": 1.3204364616801423 + }, + { + "step": 2104, + "lr": 0.0001, + "sup_loss": 1.3327367752349657 + }, + { + "step": 2105, + "lr": 0.0001, + "sup_loss": 1.3801328532419268 + }, + { + "step": 2106, + "lr": 0.0001, + "sup_loss": 1.3063631329299508 + }, + { + "step": 2107, + "lr": 0.0001, + "sup_loss": 1.3239978170888282 + }, + { + "step": 2108, + "lr": 0.0001, + "sup_loss": 1.3320880848681536 + }, + { + "step": 2109, + "lr": 0.0001, + "sup_loss": 1.3122370970472008 + }, + { + "step": 2110, + "lr": 0.0001, + "sup_loss": 1.321575087004928 + }, + { + "step": 2111, + "lr": 0.0001, + "sup_loss": 1.290006027355005 + }, + { + "step": 2112, + "lr": 0.0001, + "sup_loss": 1.3572941458122838 + }, + { + "step": 2113, + "lr": 0.0001, + "sup_loss": 1.3556785932203983 + }, + { + "step": 2114, + "lr": 0.0001, + "sup_loss": 1.3716379227489683 + }, + { + "step": 2115, + "lr": 0.0001, + "sup_loss": 1.3391857244217897 + }, + { + "step": 2116, + "lr": 0.0001, + "sup_loss": 1.324222243327907 + }, + { + "step": 2117, + "lr": 0.0001, + "sup_loss": 1.3140086931468338 + }, + { + "step": 2118, + "lr": 0.0001, + "sup_loss": 1.3406439871418883 + }, + { + "step": 2119, + "lr": 0.0001, + "sup_loss": 1.3089188618763732 + }, + { + "step": 2120, + "lr": 0.0001, + "sup_loss": 1.3183756897757082 + }, + { + "step": 2121, + "lr": 0.0001, + "sup_loss": 1.3707324574692803 + }, + { + "step": 2122, + "lr": 0.0001, + "sup_loss": 1.360244853925411 + }, + { + "step": 2123, + "lr": 0.0001, + "sup_loss": 1.3196727535568096 + }, + { + "step": 2124, + "lr": 0.0001, + "sup_loss": 1.3134277358290887 + }, + { + "step": 2125, + "lr": 0.0001, + "sup_loss": 1.3413463563050358 + }, + { + "step": 2126, + "lr": 0.0001, + "sup_loss": 1.3295564824664874 + }, + { + "step": 2127, + "lr": 0.0001, + "sup_loss": 1.31666693383427 + }, + { + "step": 2128, + "lr": 0.0001, + "sup_loss": 1.3349042630653463 + }, + { + "step": 2129, + "lr": 0.0001, + "sup_loss": 1.349416817670363 + }, + { + "step": 2130, + "lr": 0.0001, + "sup_loss": 1.329484926157641 + }, + { + "step": 2131, + "lr": 0.0001, + "sup_loss": 1.3489910525913433 + }, + { + "step": 2132, + "lr": 0.0001, + "sup_loss": 1.3445975400784798 + }, + { + "step": 2133, + "lr": 0.0001, + "sup_loss": 1.3376441114276323 + }, + { + "step": 2134, + "lr": 0.0001, + "sup_loss": 1.256542993328879 + }, + { + "step": 2135, + "lr": 0.0001, + "sup_loss": 1.3387028657961095 + }, + { + "step": 2136, + "lr": 0.0001, + "sup_loss": 1.3055971455988815 + }, + { + "step": 2137, + "lr": 0.0001, + "sup_loss": 1.3168458387730453 + }, + { + "step": 2138, + "lr": 0.0001, + "sup_loss": 1.3360651781669515 + }, + { + "step": 2139, + "lr": 0.0001, + "sup_loss": 1.306980656895867 + }, + { + "step": 2140, + "lr": 0.0001, + "sup_loss": 1.3337176120239893 + }, + { + "step": 2141, + "lr": 0.0001, + "sup_loss": 1.3939107089815508 + }, + { + "step": 2142, + "lr": 0.0001, + "sup_loss": 1.328108416397912 + }, + { + "step": 2143, + "lr": 0.0001, + "sup_loss": 1.37899123264887 + }, + { + "step": 2144, + "lr": 0.0001, + "sup_loss": 1.2823953273307112 + }, + { + "step": 2145, + "lr": 0.0001, + "sup_loss": 1.3776023411104743 + }, + { + "step": 2146, + "lr": 0.0001, + "sup_loss": 1.315631824995313 + }, + { + "step": 2147, + "lr": 0.0001, + "sup_loss": 1.3805747888653808 + }, + { + "step": 2148, + "lr": 0.0001, + "sup_loss": 1.3148594965007039 + }, + { + "step": 2149, + "lr": 0.0001, + "sup_loss": 1.3334621456026423 + }, + { + "step": 2150, + "lr": 0.0001, + "sup_loss": 1.3679707923892126, + "lyap1_mean": -4.389822006225586, + "lyap1_max": -4.314357757568359, + "lyap_spec_mean": [ + -4.389822006225586, + -4.425333023071289 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2151, + "lr": 0.0001, + "sup_loss": 1.3273265694685552 + }, + { + "step": 2152, + "lr": 0.0001, + "sup_loss": 1.3517546055228877 + }, + { + "step": 2153, + "lr": 0.0001, + "sup_loss": 1.3468313820272872 + }, + { + "step": 2154, + "lr": 0.0001, + "sup_loss": 1.375585123908039 + }, + { + "step": 2155, + "lr": 0.0001, + "sup_loss": 1.3140645252511967 + }, + { + "step": 2156, + "lr": 0.0001, + "sup_loss": 1.3143960263942513 + }, + { + "step": 2157, + "lr": 0.0001, + "sup_loss": 1.3008154481749927 + }, + { + "step": 2158, + "lr": 0.0001, + "sup_loss": 1.303763768006566 + }, + { + "step": 2159, + "lr": 0.0001, + "sup_loss": 1.3435816600898083 + }, + { + "step": 2160, + "lr": 0.0001, + "sup_loss": 1.3838424955103175 + }, + { + "step": 2161, + "lr": 0.0001, + "sup_loss": 1.3337795866598 + }, + { + "step": 2162, + "lr": 0.0001, + "sup_loss": 1.3173088087504823 + }, + { + "step": 2163, + "lr": 0.0001, + "sup_loss": 1.2535935961558726 + }, + { + "step": 2164, + "lr": 0.0001, + "sup_loss": 1.336207887569674 + }, + { + "step": 2165, + "lr": 0.0001, + "sup_loss": 1.3776271528931472 + }, + { + "step": 2166, + "lr": 0.0001, + "sup_loss": 1.3717231231434135 + }, + { + "step": 2167, + "lr": 0.0001, + "sup_loss": 1.3203665193621015 + }, + { + "step": 2168, + "lr": 0.0001, + "sup_loss": 1.3119285377262329 + }, + { + "step": 2169, + "lr": 0.0001, + "sup_loss": 1.3479718556201845 + }, + { + "step": 2170, + "lr": 0.0001, + "sup_loss": 1.362475173256755 + }, + { + "step": 2171, + "lr": 0.0001, + "sup_loss": 1.3081708880558727 + }, + { + "step": 2172, + "lr": 0.0001, + "sup_loss": 1.3457334206263774 + }, + { + "step": 2173, + "lr": 0.0001, + "sup_loss": 1.3737304003604383 + }, + { + "step": 2174, + "lr": 0.0001, + "sup_loss": 1.3785094760778036 + }, + { + "step": 2175, + "lr": 0.0001, + "sup_loss": 1.3145302411479918 + }, + { + "step": 2176, + "lr": 0.0001, + "sup_loss": 1.2889087368696637 + }, + { + "step": 2177, + "lr": 0.0001, + "sup_loss": 1.3651930000152803 + }, + { + "step": 2178, + "lr": 0.0001, + "sup_loss": 1.324622184134317 + }, + { + "step": 2179, + "lr": 0.0001, + "sup_loss": 1.3358459274740715 + }, + { + "step": 2180, + "lr": 0.0001, + "sup_loss": 1.3250251432795193 + }, + { + "step": 2181, + "lr": 0.0001, + "sup_loss": 1.3237568861540607 + }, + { + "step": 2182, + "lr": 0.0001, + "sup_loss": 1.2773238439109593 + }, + { + "step": 2183, + "lr": 0.0001, + "sup_loss": 1.3419788055225594 + }, + { + "step": 2184, + "lr": 0.0001, + "sup_loss": 1.319439250293323 + }, + { + "step": 2185, + "lr": 0.0001, + "sup_loss": 1.3383511134124657 + }, + { + "step": 2186, + "lr": 0.0001, + "sup_loss": 1.331248553676409 + }, + { + "step": 2187, + "lr": 0.0001, + "sup_loss": 1.3689994789626085 + }, + { + "step": 2188, + "lr": 0.0001, + "sup_loss": 1.3183586671511562 + }, + { + "step": 2189, + "lr": 0.0001, + "sup_loss": 1.3825720535483856 + }, + { + "step": 2190, + "lr": 0.0001, + "sup_loss": 1.2898108296775017 + }, + { + "step": 2191, + "lr": 0.0001, + "sup_loss": 1.2683795984634725 + }, + { + "step": 2192, + "lr": 0.0001, + "sup_loss": 1.3177387219222993 + }, + { + "step": 2193, + "lr": 0.0001, + "sup_loss": 1.3266058989620944 + }, + { + "step": 2194, + "lr": 0.0001, + "sup_loss": 1.344716575426023 + }, + { + "step": 2195, + "lr": 0.0001, + "sup_loss": 1.31382421395051 + }, + { + "step": 2196, + "lr": 0.0001, + "sup_loss": 1.2283617960933486 + }, + { + "step": 2197, + "lr": 0.0001, + "sup_loss": 1.2693317218364104 + }, + { + "step": 2198, + "lr": 0.0001, + "sup_loss": 1.2688353157655747 + }, + { + "step": 2199, + "lr": 0.0001, + "sup_loss": 1.2738660730075944 + }, + { + "step": 2200, + "lr": 0.0001, + "sup_loss": 1.330733796066386, + "lyap1_mean": -4.370917797088623, + "lyap1_max": -4.299170970916748, + "lyap_spec_mean": [ + -4.370917320251465, + -4.375146865844727 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2201, + "lr": 0.0001, + "sup_loss": 1.3092836169271123 + }, + { + "step": 2202, + "lr": 0.0001, + "sup_loss": 1.3644149166789004 + }, + { + "step": 2203, + "lr": 0.0001, + "sup_loss": 1.2639815556685523 + }, + { + "step": 2204, + "lr": 0.0001, + "sup_loss": 1.3415081728215852 + }, + { + "step": 2205, + "lr": 0.0001, + "sup_loss": 1.2956755063280603 + }, + { + "step": 2206, + "lr": 0.0001, + "sup_loss": 1.3345821212434483 + }, + { + "step": 2207, + "lr": 0.0001, + "sup_loss": 1.355644881675072 + }, + { + "step": 2208, + "lr": 0.0001, + "sup_loss": 1.3000607012227765 + }, + { + "step": 2209, + "lr": 0.0001, + "sup_loss": 1.344162214182756 + }, + { + "step": 2210, + "lr": 0.0001, + "sup_loss": 1.331940077121537 + }, + { + "step": 2211, + "lr": 0.0001, + "sup_loss": 1.3348133735796532 + }, + { + "step": 2212, + "lr": 0.0001, + "sup_loss": 1.3100609876390796 + }, + { + "step": 2213, + "lr": 0.0001, + "sup_loss": 1.3512849573840575 + }, + { + "step": 2214, + "lr": 0.0001, + "sup_loss": 1.307766064450689 + }, + { + "step": 2215, + "lr": 0.0001, + "sup_loss": 1.3768194698259641 + }, + { + "step": 2216, + "lr": 0.0001, + "sup_loss": 1.3288311600790281 + }, + { + "step": 2217, + "lr": 0.0001, + "sup_loss": 1.2884017186125263 + }, + { + "step": 2218, + "lr": 0.0001, + "sup_loss": 1.3851612050792368 + }, + { + "step": 2219, + "lr": 0.0001, + "sup_loss": 1.35625183607619 + }, + { + "step": 2220, + "lr": 0.0001, + "sup_loss": 1.3553910626121708 + }, + { + "step": 2221, + "lr": 0.0001, + "sup_loss": 1.3277680553585989 + }, + { + "step": 2222, + "lr": 0.0001, + "sup_loss": 1.316930014170969 + }, + { + "step": 2223, + "lr": 0.0001, + "sup_loss": 1.3302656840314706 + }, + { + "step": 2224, + "lr": 0.0001, + "sup_loss": 1.3171828529588672 + }, + { + "step": 2225, + "lr": 0.0001, + "sup_loss": 1.2797836066447923 + }, + { + "step": 2226, + "lr": 0.0001, + "sup_loss": 1.3426658261742412 + }, + { + "step": 2227, + "lr": 0.0001, + "sup_loss": 1.3537414298182049 + }, + { + "step": 2228, + "lr": 0.0001, + "sup_loss": 1.3010493371177732 + }, + { + "step": 2229, + "lr": 0.0001, + "sup_loss": 1.3117608979623676 + }, + { + "step": 2230, + "lr": 0.0001, + "sup_loss": 1.2627483786912177 + }, + { + "step": 2231, + "lr": 0.0001, + "sup_loss": 1.3356480976978193 + }, + { + "step": 2232, + "lr": 0.0001, + "sup_loss": 1.3459694476206499 + }, + { + "step": 2233, + "lr": 0.0001, + "sup_loss": 1.3710728329698072 + }, + { + "step": 2234, + "lr": 0.0001, + "sup_loss": 1.3033581821387938 + }, + { + "step": 2235, + "lr": 0.0001, + "sup_loss": 1.3140669878439564 + }, + { + "step": 2236, + "lr": 0.0001, + "sup_loss": 1.304058596801065 + }, + { + "step": 2237, + "lr": 0.0001, + "sup_loss": 1.2970413362349422 + }, + { + "step": 2238, + "lr": 0.0001, + "sup_loss": 1.3094246789408701 + }, + { + "step": 2239, + "lr": 0.0001, + "sup_loss": 1.3056587509706588 + }, + { + "step": 2240, + "lr": 0.0001, + "sup_loss": 1.2962148972815346 + }, + { + "step": 2241, + "lr": 0.0001, + "sup_loss": 1.3243387376259508 + }, + { + "step": 2242, + "lr": 0.0001, + "sup_loss": 1.293375948791174 + }, + { + "step": 2243, + "lr": 0.0001, + "sup_loss": 1.357990089939213 + }, + { + "step": 2244, + "lr": 0.0001, + "sup_loss": 1.318934825510924 + }, + { + "step": 2245, + "lr": 0.0001, + "sup_loss": 1.3476487393393164 + }, + { + "step": 2246, + "lr": 0.0001, + "sup_loss": 1.3425358741698097 + }, + { + "step": 2247, + "lr": 0.0001, + "sup_loss": 1.2768490666320824 + }, + { + "step": 2248, + "lr": 0.0001, + "sup_loss": 1.2994146343239787 + }, + { + "step": 2249, + "lr": 0.0001, + "sup_loss": 1.3038492994490618 + }, + { + "step": 2250, + "lr": 0.0001, + "sup_loss": 1.3314278343756802, + "lyap1_mean": -4.340500354766846, + "lyap1_max": -4.291837215423584, + "lyap_spec_mean": [ + -4.340500354766846, + -4.350625038146973 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2251, + "lr": 0.0001, + "sup_loss": 1.3000639445656519 + }, + { + "step": 2252, + "lr": 0.0001, + "sup_loss": 1.3034281148985618 + }, + { + "step": 2253, + "lr": 0.0001, + "sup_loss": 1.3396158917665675 + }, + { + "step": 2254, + "lr": 0.0001, + "sup_loss": 1.3285482061508742 + }, + { + "step": 2255, + "lr": 0.0001, + "sup_loss": 1.297098097064154 + }, + { + "step": 2256, + "lr": 0.0001, + "sup_loss": 1.312664637711699 + }, + { + "step": 2257, + "lr": 0.0001, + "sup_loss": 1.2923063818965888 + }, + { + "step": 2258, + "lr": 0.0001, + "sup_loss": 1.3235237463312237 + }, + { + "step": 2259, + "lr": 0.0001, + "sup_loss": 1.234957318875583 + }, + { + "step": 2260, + "lr": 0.0001, + "sup_loss": 1.286953514482732 + }, + { + "step": 2261, + "lr": 0.0001, + "sup_loss": 1.3518256800519548 + }, + { + "step": 2262, + "lr": 0.0001, + "sup_loss": 1.33673899038314 + }, + { + "step": 2263, + "lr": 0.0001, + "sup_loss": 1.3243817718249924 + }, + { + "step": 2264, + "lr": 0.0001, + "sup_loss": 1.2935011632597295 + }, + { + "step": 2265, + "lr": 0.0001, + "sup_loss": 1.2461945702068586 + }, + { + "step": 2266, + "lr": 0.0001, + "sup_loss": 1.2963698984102026 + }, + { + "step": 2267, + "lr": 0.0001, + "sup_loss": 1.3614569599735733 + }, + { + "step": 2268, + "lr": 0.0001, + "sup_loss": 1.3250678520458063 + }, + { + "step": 2269, + "lr": 0.0001, + "sup_loss": 1.2831093288148319 + }, + { + "step": 2270, + "lr": 0.0001, + "sup_loss": 1.304212326643754 + }, + { + "step": 2271, + "lr": 0.0001, + "sup_loss": 1.2703855860986704 + }, + { + "step": 2272, + "lr": 0.0001, + "sup_loss": 1.346533419892547 + }, + { + "step": 2273, + "lr": 0.0001, + "sup_loss": 1.3059458536543742 + }, + { + "step": 2274, + "lr": 0.0001, + "sup_loss": 1.3303298092786495 + }, + { + "step": 2275, + "lr": 0.0001, + "sup_loss": 1.3028803981568586 + }, + { + "step": 2276, + "lr": 0.0001, + "sup_loss": 1.322915034185758 + }, + { + "step": 2277, + "lr": 0.0001, + "sup_loss": 1.3117877563801217 + }, + { + "step": 2278, + "lr": 0.0001, + "sup_loss": 1.3404323568512164 + }, + { + "step": 2279, + "lr": 0.0001, + "sup_loss": 1.3483420061442617 + }, + { + "step": 2280, + "lr": 0.0001, + "sup_loss": 1.288083327219387 + }, + { + "step": 2281, + "lr": 0.0001, + "sup_loss": 1.3356251847063094 + }, + { + "step": 2282, + "lr": 0.0001, + "sup_loss": 1.2898513851524769 + }, + { + "step": 2283, + "lr": 0.0001, + "sup_loss": 1.3569953548869098 + }, + { + "step": 2284, + "lr": 0.0001, + "sup_loss": 1.264187957193366 + }, + { + "step": 2285, + "lr": 0.0001, + "sup_loss": 1.2627206931312875 + }, + { + "step": 2286, + "lr": 0.0001, + "sup_loss": 1.2841785237360703 + }, + { + "step": 2287, + "lr": 0.0001, + "sup_loss": 1.3559804829356044 + }, + { + "step": 2288, + "lr": 0.0001, + "sup_loss": 1.296922265892696 + }, + { + "step": 2289, + "lr": 0.0001, + "sup_loss": 1.2987764845396852 + }, + { + "step": 2290, + "lr": 0.0001, + "sup_loss": 1.2793764593998067 + }, + { + "step": 2291, + "lr": 0.0001, + "sup_loss": 1.3221652888963566 + }, + { + "step": 2292, + "lr": 0.0001, + "sup_loss": 1.3641623010100081 + }, + { + "step": 2293, + "lr": 0.0001, + "sup_loss": 1.213996607716935 + }, + { + "step": 2294, + "lr": 0.0001, + "sup_loss": 1.3065556275077215 + }, + { + "step": 2295, + "lr": 0.0001, + "sup_loss": 1.2874602900935868 + }, + { + "step": 2296, + "lr": 0.0001, + "sup_loss": 1.3087776584520365 + }, + { + "step": 2297, + "lr": 0.0001, + "sup_loss": 1.3401450155556218 + }, + { + "step": 2298, + "lr": 0.0001, + "sup_loss": 1.2629370985379633 + }, + { + "step": 2299, + "lr": 0.0001, + "sup_loss": 1.281192253778699 + }, + { + "step": 2300, + "lr": 0.0001, + "sup_loss": 1.3378097323120646, + "lyap1_mean": -4.279443740844727, + "lyap1_max": -4.232276916503906, + "lyap_spec_mean": [ + -4.279443740844727, + -4.32424783706665 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2301, + "lr": 0.0001, + "sup_loss": 1.3007858713339784 + }, + { + "step": 2302, + "lr": 0.0001, + "sup_loss": 1.3257725206791242 + }, + { + "step": 2303, + "lr": 0.0001, + "sup_loss": 1.2849550329691797 + }, + { + "step": 2304, + "lr": 0.0001, + "sup_loss": 1.31333355293645 + }, + { + "step": 2305, + "lr": 0.0001, + "sup_loss": 1.242690810045472 + }, + { + "step": 2306, + "lr": 0.0001, + "sup_loss": 1.2955308721126266 + }, + { + "step": 2307, + "lr": 0.0001, + "sup_loss": 1.297947357002302 + }, + { + "step": 2308, + "lr": 0.0001, + "sup_loss": 1.3009446400414433 + }, + { + "step": 2309, + "lr": 0.0001, + "sup_loss": 1.306174469920154 + }, + { + "step": 2310, + "lr": 0.0001, + "sup_loss": 1.3386318546068736 + }, + { + "step": 2311, + "lr": 0.0001, + "sup_loss": 1.297960029837302 + }, + { + "step": 2312, + "lr": 0.0001, + "sup_loss": 1.301810373709632 + }, + { + "step": 2313, + "lr": 0.0001, + "sup_loss": 1.3089081595526004 + }, + { + "step": 2314, + "lr": 0.0001, + "sup_loss": 1.3210347724118987 + }, + { + "step": 2315, + "lr": 0.0001, + "sup_loss": 1.3101104274607664 + }, + { + "step": 2316, + "lr": 0.0001, + "sup_loss": 1.320553458028757 + }, + { + "step": 2317, + "lr": 0.0001, + "sup_loss": 1.290975766284836 + }, + { + "step": 2318, + "lr": 0.0001, + "sup_loss": 1.316027805083375 + }, + { + "step": 2319, + "lr": 0.0001, + "sup_loss": 1.2880183877077627 + }, + { + "step": 2320, + "lr": 0.0001, + "sup_loss": 1.3236236642933614 + }, + { + "step": 2321, + "lr": 0.0001, + "sup_loss": 1.305926610724108 + }, + { + "step": 2322, + "lr": 0.0001, + "sup_loss": 1.3326279069545166 + }, + { + "step": 2323, + "lr": 0.0001, + "sup_loss": 1.2911964906673188 + }, + { + "step": 2324, + "lr": 0.0001, + "sup_loss": 1.3329212298071615 + }, + { + "step": 2325, + "lr": 0.0001, + "sup_loss": 1.2927224436214344 + }, + { + "step": 2326, + "lr": 0.0001, + "sup_loss": 1.2902418414141705 + }, + { + "step": 2327, + "lr": 0.0001, + "sup_loss": 1.2870042702625197 + }, + { + "step": 2328, + "lr": 0.0001, + "sup_loss": 1.3122620901358362 + }, + { + "step": 2329, + "lr": 0.0001, + "sup_loss": 1.3147664825114576 + }, + { + "step": 2330, + "lr": 0.0001, + "sup_loss": 1.2560404035459811 + }, + { + "step": 2331, + "lr": 0.0001, + "sup_loss": 1.262692801802689 + }, + { + "step": 2332, + "lr": 0.0001, + "sup_loss": 1.3433351122740804 + }, + { + "step": 2333, + "lr": 0.0001, + "sup_loss": 1.2864438095682962 + }, + { + "step": 2334, + "lr": 0.0001, + "sup_loss": 1.3354133653173805 + }, + { + "step": 2335, + "lr": 0.0001, + "sup_loss": 1.282173158019353 + }, + { + "step": 2336, + "lr": 0.0001, + "sup_loss": 1.2734277734282753 + }, + { + "step": 2337, + "lr": 0.0001, + "sup_loss": 1.3083462499143748 + }, + { + "step": 2338, + "lr": 0.0001, + "sup_loss": 1.2852205000510637 + }, + { + "step": 2339, + "lr": 0.0001, + "sup_loss": 1.2773747932786292 + }, + { + "step": 2340, + "lr": 0.0001, + "sup_loss": 1.3204464365240287 + }, + { + "step": 2341, + "lr": 0.0001, + "sup_loss": 1.3126080650564995 + }, + { + "step": 2342, + "lr": 0.0001, + "sup_loss": 1.296881097565329 + }, + { + "step": 2343, + "lr": 0.0001, + "sup_loss": 1.2790243381960729 + }, + { + "step": 2344, + "lr": 0.0001, + "sup_loss": 1.2858772879976104 + }, + { + "step": 2345, + "lr": 0.0001, + "sup_loss": 1.2891286760926386 + }, + { + "step": 2346, + "lr": 0.0001, + "sup_loss": 1.2891443964823313 + }, + { + "step": 2347, + "lr": 0.0001, + "sup_loss": 1.2526664140698167 + }, + { + "step": 2348, + "lr": 0.0001, + "sup_loss": 1.2566865753657532 + }, + { + "step": 2349, + "lr": 0.0001, + "sup_loss": 1.2132622038014034 + }, + { + "step": 2350, + "lr": 0.0001, + "sup_loss": 1.3199532792448685, + "lyap1_mean": -4.297420024871826, + "lyap1_max": -4.208258628845215, + "lyap_spec_mean": [ + -4.297419548034668, + -4.2948503494262695 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2351, + "lr": 0.0001, + "sup_loss": 1.3260009331325753 + }, + { + "step": 2352, + "lr": 0.0001, + "sup_loss": 1.287499754615069 + }, + { + "step": 2353, + "lr": 0.0001, + "sup_loss": 1.3175281646058237 + }, + { + "step": 2354, + "lr": 0.0001, + "sup_loss": 1.3285812832935602 + }, + { + "step": 2355, + "lr": 0.0001, + "sup_loss": 1.338241712745097 + }, + { + "step": 2356, + "lr": 0.0001, + "sup_loss": 1.3458525924552727 + }, + { + "step": 2357, + "lr": 0.0001, + "sup_loss": 1.2952742371828823 + }, + { + "step": 2358, + "lr": 0.0001, + "sup_loss": 1.2742454256445066 + }, + { + "step": 2359, + "lr": 0.0001, + "sup_loss": 1.2319133298195264 + }, + { + "step": 2360, + "lr": 0.0001, + "sup_loss": 1.285986288064156 + }, + { + "step": 2361, + "lr": 0.0001, + "sup_loss": 1.3126345716440837 + }, + { + "step": 2362, + "lr": 0.0001, + "sup_loss": 1.3206846608730833 + }, + { + "step": 2363, + "lr": 0.0001, + "sup_loss": 1.3302782117074967 + }, + { + "step": 2364, + "lr": 0.0001, + "sup_loss": 1.2971833068745262 + }, + { + "step": 2365, + "lr": 0.0001, + "sup_loss": 1.3219994814629266 + }, + { + "step": 2366, + "lr": 0.0001, + "sup_loss": 1.2504207152502218 + }, + { + "step": 2367, + "lr": 0.0001, + "sup_loss": 1.2684664150500888 + }, + { + "step": 2368, + "lr": 0.0001, + "sup_loss": 1.285101694636452 + }, + { + "step": 2369, + "lr": 0.0001, + "sup_loss": 1.2934585618586536 + }, + { + "step": 2370, + "lr": 0.0001, + "sup_loss": 1.2777614769302308 + }, + { + "step": 2371, + "lr": 0.0001, + "sup_loss": 1.2467405513847356 + }, + { + "step": 2372, + "lr": 0.0001, + "sup_loss": 1.2657364330853962 + }, + { + "step": 2373, + "lr": 0.0001, + "sup_loss": 1.2940289240047569 + }, + { + "step": 2374, + "lr": 0.0001, + "sup_loss": 1.3017253523917187 + }, + { + "step": 2375, + "lr": 0.0001, + "sup_loss": 1.3413423609738866 + }, + { + "step": 2376, + "lr": 0.0001, + "sup_loss": 1.3098601447706604 + }, + { + "step": 2377, + "lr": 0.0001, + "sup_loss": 1.2789357624995552 + }, + { + "step": 2378, + "lr": 0.0001, + "sup_loss": 1.2458950663824655 + }, + { + "step": 2379, + "lr": 0.0001, + "sup_loss": 1.2543408363804593 + }, + { + "step": 2380, + "lr": 0.0001, + "sup_loss": 1.2470318968628917 + }, + { + "step": 2381, + "lr": 0.0001, + "sup_loss": 1.2973113604321573 + }, + { + "step": 2382, + "lr": 0.0001, + "sup_loss": 1.296711494089275 + }, + { + "step": 2383, + "lr": 0.0001, + "sup_loss": 1.298832765455335 + }, + { + "step": 2384, + "lr": 0.0001, + "sup_loss": 1.2254319481020883 + }, + { + "step": 2385, + "lr": 0.0001, + "sup_loss": 1.3381799252639806 + }, + { + "step": 2386, + "lr": 0.0001, + "sup_loss": 1.2801464966189444 + }, + { + "step": 2387, + "lr": 0.0001, + "sup_loss": 1.308961306638708 + }, + { + "step": 2388, + "lr": 0.0001, + "sup_loss": 1.225490189906738 + }, + { + "step": 2389, + "lr": 0.0001, + "sup_loss": 1.26901640122553 + }, + { + "step": 2390, + "lr": 0.0001, + "sup_loss": 1.2838795127609883 + }, + { + "step": 2391, + "lr": 0.0001, + "sup_loss": 1.3317961906134506 + }, + { + "step": 2392, + "lr": 0.0001, + "sup_loss": 1.2411537722106925 + }, + { + "step": 2393, + "lr": 0.0001, + "sup_loss": 1.2786701588518103 + }, + { + "step": 2394, + "lr": 0.0001, + "sup_loss": 1.2948194968822064 + }, + { + "step": 2395, + "lr": 0.0001, + "sup_loss": 1.2738479733538153 + }, + { + "step": 2396, + "lr": 0.0001, + "sup_loss": 1.2218023667057016 + }, + { + "step": 2397, + "lr": 0.0001, + "sup_loss": 1.2689629790696668 + }, + { + "step": 2398, + "lr": 0.0001, + "sup_loss": 1.280866070768354 + }, + { + "step": 2399, + "lr": 0.0001, + "sup_loss": 1.293000455540708 + }, + { + "step": 2400, + "lr": 0.0001, + "sup_loss": 1.3015417143182788, + "lyap1_mean": -4.240116596221924, + "lyap1_max": -4.1728386878967285, + "lyap_spec_mean": [ + -4.240116596221924, + -4.259872913360596 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2401, + "lr": 0.0001, + "sup_loss": 1.2946066138545067 + }, + { + "step": 2402, + "lr": 0.0001, + "sup_loss": 1.306802843214579 + }, + { + "step": 2403, + "lr": 0.0001, + "sup_loss": 1.2859214071476572 + }, + { + "step": 2404, + "lr": 0.0001, + "sup_loss": 1.2818976045991124 + }, + { + "step": 2405, + "lr": 0.0001, + "sup_loss": 1.298702635190277 + }, + { + "step": 2406, + "lr": 0.0001, + "sup_loss": 1.2683154138622867 + }, + { + "step": 2407, + "lr": 0.0001, + "sup_loss": 1.2930010072673241 + }, + { + "step": 2408, + "lr": 0.0001, + "sup_loss": 1.28000310706559 + }, + { + "step": 2409, + "lr": 0.0001, + "sup_loss": 1.2550430496003386 + }, + { + "step": 2410, + "lr": 0.0001, + "sup_loss": 1.2639766048330499 + }, + { + "step": 2411, + "lr": 0.0001, + "sup_loss": 1.254134811758989 + }, + { + "step": 2412, + "lr": 0.0001, + "sup_loss": 1.2460116320165038 + }, + { + "step": 2413, + "lr": 0.0001, + "sup_loss": 1.2728647458887183 + }, + { + "step": 2414, + "lr": 0.0001, + "sup_loss": 1.318575239374344 + }, + { + "step": 2415, + "lr": 0.0001, + "sup_loss": 1.30180953985345 + }, + { + "step": 2416, + "lr": 0.0001, + "sup_loss": 1.2474197947403924 + }, + { + "step": 2417, + "lr": 0.0001, + "sup_loss": 1.2773624807953932 + }, + { + "step": 2418, + "lr": 0.0001, + "sup_loss": 1.299110880659272 + }, + { + "step": 2419, + "lr": 0.0001, + "sup_loss": 1.2912462042806558 + }, + { + "step": 2420, + "lr": 0.0001, + "sup_loss": 1.2781167180210447 + }, + { + "step": 2421, + "lr": 0.0001, + "sup_loss": 1.2624044367222242 + }, + { + "step": 2422, + "lr": 0.0001, + "sup_loss": 1.2567010590057595 + }, + { + "step": 2423, + "lr": 0.0001, + "sup_loss": 1.2735732058618787 + }, + { + "step": 2424, + "lr": 0.0001, + "sup_loss": 1.2617191771051555 + }, + { + "step": 2425, + "lr": 0.0001, + "sup_loss": 1.254120966278177 + }, + { + "step": 2426, + "lr": 0.0001, + "sup_loss": 1.2726287865388617 + }, + { + "step": 2427, + "lr": 0.0001, + "sup_loss": 1.296165394747546 + }, + { + "step": 2428, + "lr": 0.0001, + "sup_loss": 1.2621463093106076 + }, + { + "step": 2429, + "lr": 0.0001, + "sup_loss": 1.2831554361124158 + }, + { + "step": 2430, + "lr": 0.0001, + "sup_loss": 1.2736333565784848 + }, + { + "step": 2431, + "lr": 0.0001, + "sup_loss": 1.2457267881996474 + }, + { + "step": 2432, + "lr": 0.0001, + "sup_loss": 1.3013917129349992 + }, + { + "step": 2433, + "lr": 0.0001, + "sup_loss": 1.3168799829825315 + }, + { + "step": 2434, + "lr": 0.0001, + "sup_loss": 1.2908628853594517 + }, + { + "step": 2435, + "lr": 0.0001, + "sup_loss": 1.2259381371584663 + }, + { + "step": 2436, + "lr": 0.0001, + "sup_loss": 1.2320734466792544 + }, + { + "step": 2437, + "lr": 0.0001, + "sup_loss": 1.3015850702337257 + }, + { + "step": 2438, + "lr": 0.0001, + "sup_loss": 1.272234096262415 + }, + { + "step": 2439, + "lr": 0.0001, + "sup_loss": 1.2892698855646032 + }, + { + "step": 2440, + "lr": 0.0001, + "sup_loss": 1.2817456438351889 + }, + { + "step": 2441, + "lr": 0.0001, + "sup_loss": 1.3086320329068524 + }, + { + "step": 2442, + "lr": 0.0001, + "sup_loss": 1.2150263443886868 + }, + { + "step": 2443, + "lr": 0.0001, + "sup_loss": 1.3220695734040846 + }, + { + "step": 2444, + "lr": 0.0001, + "sup_loss": 1.2880881516594758 + }, + { + "step": 2445, + "lr": 0.0001, + "sup_loss": 1.255566127178477 + }, + { + "step": 2446, + "lr": 0.0001, + "sup_loss": 1.2918217794722304 + }, + { + "step": 2447, + "lr": 0.0001, + "sup_loss": 1.265959883368338 + }, + { + "step": 2448, + "lr": 0.0001, + "sup_loss": 1.2508129313012017 + }, + { + "step": 2449, + "lr": 0.0001, + "sup_loss": 1.2788072625567455 + }, + { + "step": 2450, + "lr": 0.0001, + "sup_loss": 1.2966244264743472, + "lyap1_mean": -4.229255199432373, + "lyap1_max": -4.196020603179932, + "lyap_spec_mean": [ + -4.229255199432373, + -4.262547492980957 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2451, + "lr": 0.0001, + "sup_loss": 1.2504113864509403 + }, + { + "step": 2452, + "lr": 0.0001, + "sup_loss": 1.246732217642998 + }, + { + "step": 2453, + "lr": 0.0001, + "sup_loss": 1.2849490521020903 + }, + { + "step": 2454, + "lr": 0.0001, + "sup_loss": 1.2892670504853885 + }, + { + "step": 2455, + "lr": 0.0001, + "sup_loss": 1.2117253504047698 + }, + { + "step": 2456, + "lr": 0.0001, + "sup_loss": 1.3424819013472709 + }, + { + "step": 2457, + "lr": 0.0001, + "sup_loss": 1.289108257120321 + }, + { + "step": 2458, + "lr": 0.0001, + "sup_loss": 1.2898390222001384 + }, + { + "step": 2459, + "lr": 0.0001, + "sup_loss": 1.2827777128936115 + }, + { + "step": 2460, + "lr": 0.0001, + "sup_loss": 1.2716542126633752 + }, + { + "step": 2461, + "lr": 0.0001, + "sup_loss": 1.267684941688289 + }, + { + "step": 2462, + "lr": 0.0001, + "sup_loss": 1.3097554413412988 + }, + { + "step": 2463, + "lr": 0.0001, + "sup_loss": 1.2194675708162992 + }, + { + "step": 2464, + "lr": 0.0001, + "sup_loss": 1.3035253313827346 + }, + { + "step": 2465, + "lr": 0.0001, + "sup_loss": 1.2342608405233164 + }, + { + "step": 2466, + "lr": 0.0001, + "sup_loss": 1.2967217855370181 + }, + { + "step": 2467, + "lr": 0.0001, + "sup_loss": 1.215006770190903 + }, + { + "step": 2468, + "lr": 0.0001, + "sup_loss": 1.3502632928250051 + }, + { + "step": 2469, + "lr": 0.0001, + "sup_loss": 1.2625590826493243 + }, + { + "step": 2470, + "lr": 0.0001, + "sup_loss": 1.2648553913926301 + }, + { + "step": 2471, + "lr": 0.0001, + "sup_loss": 1.295449054032632 + }, + { + "step": 2472, + "lr": 0.0001, + "sup_loss": 1.3336467729727075 + }, + { + "step": 2473, + "lr": 0.0001, + "sup_loss": 1.2827146369448235 + }, + { + "step": 2474, + "lr": 0.0001, + "sup_loss": 1.269958354153474 + }, + { + "step": 2475, + "lr": 0.0001, + "sup_loss": 1.2487130240178912 + }, + { + "step": 2476, + "lr": 0.0001, + "sup_loss": 1.279820387709458 + }, + { + "step": 2477, + "lr": 0.0001, + "sup_loss": 1.3022651386449888 + }, + { + "step": 2478, + "lr": 0.0001, + "sup_loss": 1.3054360744302722 + }, + { + "step": 2479, + "lr": 0.0001, + "sup_loss": 1.2928549955115907 + }, + { + "step": 2480, + "lr": 0.0001, + "sup_loss": 1.2153522634201608 + }, + { + "step": 2481, + "lr": 0.0001, + "sup_loss": 1.2875561582938806 + }, + { + "step": 2482, + "lr": 0.0001, + "sup_loss": 1.267215253171082 + }, + { + "step": 2483, + "lr": 0.0001, + "sup_loss": 1.229934348336454 + }, + { + "step": 2484, + "lr": 0.0001, + "sup_loss": 1.213394197330342 + }, + { + "step": 2485, + "lr": 0.0001, + "sup_loss": 1.2528756305615625 + }, + { + "step": 2486, + "lr": 0.0001, + "sup_loss": 1.2667774988689504 + }, + { + "step": 2487, + "lr": 0.0001, + "sup_loss": 1.283049295912387 + }, + { + "step": 2488, + "lr": 0.0001, + "sup_loss": 1.2600793211833328 + }, + { + "step": 2489, + "lr": 0.0001, + "sup_loss": 1.2370128738967054 + }, + { + "step": 2490, + "lr": 0.0001, + "sup_loss": 1.2739358335614426 + }, + { + "step": 2491, + "lr": 0.0001, + "sup_loss": 1.2538356788654506 + }, + { + "step": 2492, + "lr": 0.0001, + "sup_loss": 1.2763594495617916 + }, + { + "step": 2493, + "lr": 0.0001, + "sup_loss": 1.258723758548922 + }, + { + "step": 2494, + "lr": 0.0001, + "sup_loss": 1.279014893825708 + }, + { + "step": 2495, + "lr": 0.0001, + "sup_loss": 1.2417430219735484 + }, + { + "step": 2496, + "lr": 0.0001, + "sup_loss": 1.2090542912444422 + }, + { + "step": 2497, + "lr": 0.0001, + "sup_loss": 1.2765879568712852 + }, + { + "step": 2498, + "lr": 0.0001, + "sup_loss": 1.291159374913085 + }, + { + "step": 2499, + "lr": 0.0001, + "sup_loss": 1.2514413679581802 + }, + { + "step": 2500, + "lr": 0.0001, + "sup_loss": 1.2000801420569038, + "lyap1_mean": -4.217179298400879, + "lyap1_max": -4.172418117523193, + "lyap_spec_mean": [ + -4.217179298400879, + -4.243560314178467 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2501, + "lr": 0.0001, + "sup_loss": 1.2439328700323946 + }, + { + "step": 2502, + "lr": 0.0001, + "sup_loss": 1.3143452509486122 + }, + { + "step": 2503, + "lr": 0.0001, + "sup_loss": 1.2673685129943661 + }, + { + "step": 2504, + "lr": 0.0001, + "sup_loss": 1.2808396534469415 + }, + { + "step": 2505, + "lr": 0.0001, + "sup_loss": 1.2310802179945637 + }, + { + "step": 2506, + "lr": 0.0001, + "sup_loss": 1.2173190142924624 + }, + { + "step": 2507, + "lr": 0.0001, + "sup_loss": 1.3448147837455946 + }, + { + "step": 2508, + "lr": 0.0001, + "sup_loss": 1.3251125576385232 + }, + { + "step": 2509, + "lr": 0.0001, + "sup_loss": 1.287083943906881 + }, + { + "step": 2510, + "lr": 0.0001, + "sup_loss": 1.242063283896983 + }, + { + "step": 2511, + "lr": 0.0001, + "sup_loss": 1.2420088034638834 + }, + { + "step": 2512, + "lr": 0.0001, + "sup_loss": 1.2524525098606696 + }, + { + "step": 2513, + "lr": 0.0001, + "sup_loss": 1.2946149493114563 + }, + { + "step": 2514, + "lr": 0.0001, + "sup_loss": 1.1929837765898448 + }, + { + "step": 2515, + "lr": 0.0001, + "sup_loss": 1.2787169941663579 + }, + { + "step": 2516, + "lr": 0.0001, + "sup_loss": 1.3020050720880492 + }, + { + "step": 2517, + "lr": 0.0001, + "sup_loss": 1.2479310861141053 + }, + { + "step": 2518, + "lr": 0.0001, + "sup_loss": 1.2811408140366618 + }, + { + "step": 2519, + "lr": 0.0001, + "sup_loss": 1.3105722151334374 + }, + { + "step": 2520, + "lr": 0.0001, + "sup_loss": 1.235313479271157 + }, + { + "step": 2521, + "lr": 0.0001, + "sup_loss": 1.302235660512153 + }, + { + "step": 2522, + "lr": 0.0001, + "sup_loss": 1.298328913905733 + }, + { + "step": 2523, + "lr": 0.0001, + "sup_loss": 1.2939428741425083 + }, + { + "step": 2524, + "lr": 0.0001, + "sup_loss": 1.2890248321156432 + }, + { + "step": 2525, + "lr": 0.0001, + "sup_loss": 1.2472886043704121 + }, + { + "step": 2526, + "lr": 0.0001, + "sup_loss": 1.2207688130107575 + }, + { + "step": 2527, + "lr": 0.0001, + "sup_loss": 1.259757747898356 + }, + { + "step": 2528, + "lr": 0.0001, + "sup_loss": 1.3041591155231702 + }, + { + "step": 2529, + "lr": 0.0001, + "sup_loss": 1.2262317617995946 + }, + { + "step": 2530, + "lr": 0.0001, + "sup_loss": 1.294238339449141 + }, + { + "step": 2531, + "lr": 0.0001, + "sup_loss": 1.2852696308314464 + }, + { + "step": 2532, + "lr": 0.0001, + "sup_loss": 1.2075079080098947 + }, + { + "step": 2533, + "lr": 0.0001, + "sup_loss": 1.3465302715892369 + }, + { + "step": 2534, + "lr": 0.0001, + "sup_loss": 1.2334916595477938 + }, + { + "step": 2535, + "lr": 0.0001, + "sup_loss": 1.2522230589393377 + }, + { + "step": 2536, + "lr": 0.0001, + "sup_loss": 1.234307174978886 + }, + { + "step": 2537, + "lr": 0.0001, + "sup_loss": 1.275342292878406 + }, + { + "step": 2538, + "lr": 0.0001, + "sup_loss": 1.220077455024498 + }, + { + "step": 2539, + "lr": 0.0001, + "sup_loss": 1.2531405036580414 + }, + { + "step": 2540, + "lr": 0.0001, + "sup_loss": 1.2796458763756555 + }, + { + "step": 2541, + "lr": 0.0001, + "sup_loss": 1.2231552348355517 + }, + { + "step": 2542, + "lr": 0.0001, + "sup_loss": 1.2595762006221412 + }, + { + "step": 2543, + "lr": 0.0001, + "sup_loss": 1.2839878766508974 + }, + { + "step": 2544, + "lr": 0.0001, + "sup_loss": 1.2644498208258539 + }, + { + "step": 2545, + "lr": 0.0001, + "sup_loss": 1.257505981434681 + }, + { + "step": 2546, + "lr": 0.0001, + "sup_loss": 1.2642471513879407 + }, + { + "step": 2547, + "lr": 0.0001, + "sup_loss": 1.2607148550835343 + }, + { + "step": 2548, + "lr": 0.0001, + "sup_loss": 1.2942780475383033 + }, + { + "step": 2549, + "lr": 0.0001, + "sup_loss": 1.2503602850289803 + }, + { + "step": 2550, + "lr": 0.0001, + "sup_loss": 1.2673350576101512, + "lyap1_mean": -4.21592903137207, + "lyap1_max": -4.153813362121582, + "lyap_spec_mean": [ + -4.21592903137207, + -4.224661350250244 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2551, + "lr": 0.0001, + "sup_loss": 1.2887762823339455 + }, + { + "step": 2552, + "lr": 0.0001, + "sup_loss": 1.241141103749948 + }, + { + "step": 2553, + "lr": 0.0001, + "sup_loss": 1.262704091041656 + }, + { + "step": 2554, + "lr": 0.0001, + "sup_loss": 1.2535835200065104 + }, + { + "step": 2555, + "lr": 0.0001, + "sup_loss": 1.2706815370886373 + }, + { + "step": 2556, + "lr": 0.0001, + "sup_loss": 1.2076767199113734 + }, + { + "step": 2557, + "lr": 0.0001, + "sup_loss": 1.2880257333903509 + }, + { + "step": 2558, + "lr": 0.0001, + "sup_loss": 1.2545560325594527 + }, + { + "step": 2559, + "lr": 0.0001, + "sup_loss": 1.187565222373949 + }, + { + "step": 2560, + "lr": 0.0001, + "sup_loss": 1.2987840760479166 + }, + { + "step": 2561, + "lr": 0.0001, + "sup_loss": 1.257779380655759 + }, + { + "step": 2562, + "lr": 0.0001, + "sup_loss": 1.2682001244281944 + }, + { + "step": 2563, + "lr": 0.0001, + "sup_loss": 1.2517458785409872 + }, + { + "step": 2564, + "lr": 0.0001, + "sup_loss": 1.2393170114115994 + }, + { + "step": 2565, + "lr": 0.0001, + "sup_loss": 1.2290434838186444 + }, + { + "step": 2566, + "lr": 0.0001, + "sup_loss": 1.2609742271144768 + }, + { + "step": 2567, + "lr": 0.0001, + "sup_loss": 1.2380305560369997 + }, + { + "step": 2568, + "lr": 0.0001, + "sup_loss": 1.262483511359272 + }, + { + "step": 2569, + "lr": 0.0001, + "sup_loss": 1.2258235396637527 + }, + { + "step": 2570, + "lr": 0.0001, + "sup_loss": 1.2685639145590661 + }, + { + "step": 2571, + "lr": 0.0001, + "sup_loss": 1.2795514178158474 + }, + { + "step": 2572, + "lr": 0.0001, + "sup_loss": 1.2661739093207907 + }, + { + "step": 2573, + "lr": 0.0001, + "sup_loss": 1.279123890841784 + }, + { + "step": 2574, + "lr": 0.0001, + "sup_loss": 1.2732338339180482 + }, + { + "step": 2575, + "lr": 0.0001, + "sup_loss": 1.274722929177498 + }, + { + "step": 2576, + "lr": 0.0001, + "sup_loss": 1.2859501997540614 + }, + { + "step": 2577, + "lr": 0.0001, + "sup_loss": 1.2371998753680382 + }, + { + "step": 2578, + "lr": 0.0001, + "sup_loss": 1.1754687670090191 + }, + { + "step": 2579, + "lr": 0.0001, + "sup_loss": 1.2441350495107462 + }, + { + "step": 2580, + "lr": 0.0001, + "sup_loss": 1.2698504175062326 + }, + { + "step": 2581, + "lr": 0.0001, + "sup_loss": 1.1897744577146239 + }, + { + "step": 2582, + "lr": 0.0001, + "sup_loss": 1.2514506964149756 + }, + { + "step": 2583, + "lr": 0.0001, + "sup_loss": 1.2711750923048821 + }, + { + "step": 2584, + "lr": 0.0001, + "sup_loss": 1.2116420451454948 + }, + { + "step": 2585, + "lr": 0.0001, + "sup_loss": 1.2466947111136313 + }, + { + "step": 2586, + "lr": 0.0001, + "sup_loss": 1.2921165799422651 + }, + { + "step": 2587, + "lr": 0.0001, + "sup_loss": 1.2430475776854952 + }, + { + "step": 2588, + "lr": 0.0001, + "sup_loss": 1.2835425552678275 + }, + { + "step": 2589, + "lr": 0.0001, + "sup_loss": 1.2480793811438373 + }, + { + "step": 2590, + "lr": 0.0001, + "sup_loss": 1.276947118539664 + }, + { + "step": 2591, + "lr": 0.0001, + "sup_loss": 1.2519617062660808 + }, + { + "step": 2592, + "lr": 0.0001, + "sup_loss": 1.2455620593904937 + }, + { + "step": 2593, + "lr": 0.0001, + "sup_loss": 1.2547673263926888 + }, + { + "step": 2594, + "lr": 0.0001, + "sup_loss": 1.2863320880519333 + }, + { + "step": 2595, + "lr": 0.0001, + "sup_loss": 1.1976371455494406 + }, + { + "step": 2596, + "lr": 0.0001, + "sup_loss": 1.2509705637084054 + }, + { + "step": 2597, + "lr": 0.0001, + "sup_loss": 1.17630289895003 + }, + { + "step": 2598, + "lr": 0.0001, + "sup_loss": 1.2573487784809798 + }, + { + "step": 2599, + "lr": 0.0001, + "sup_loss": 1.2152991887407907 + }, + { + "step": 2600, + "lr": 0.0001, + "sup_loss": 1.266431682760794, + "lyap1_mean": -4.144527912139893, + "lyap1_max": -4.123527526855469, + "lyap_spec_mean": [ + -4.144528388977051, + -4.153683662414551 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2601, + "lr": 0.0001, + "sup_loss": 1.23895705764164 + }, + { + "step": 2602, + "lr": 0.0001, + "sup_loss": 1.2688821114915814 + }, + { + "step": 2603, + "lr": 0.0001, + "sup_loss": 1.2083745009795481 + }, + { + "step": 2604, + "lr": 0.0001, + "sup_loss": 1.2364987732156745 + }, + { + "step": 2605, + "lr": 0.0001, + "sup_loss": 1.232254561597169 + }, + { + "step": 2606, + "lr": 0.0001, + "sup_loss": 1.2348598758111264 + }, + { + "step": 2607, + "lr": 0.0001, + "sup_loss": 1.2353866991555655 + }, + { + "step": 2608, + "lr": 0.0001, + "sup_loss": 1.2618848504744413 + }, + { + "step": 2609, + "lr": 0.0001, + "sup_loss": 1.2672213401881256 + }, + { + "step": 2610, + "lr": 0.0001, + "sup_loss": 1.2346763322061476 + }, + { + "step": 2611, + "lr": 0.0001, + "sup_loss": 1.2315768670526297 + }, + { + "step": 2612, + "lr": 0.0001, + "sup_loss": 1.2328104890937324 + }, + { + "step": 2613, + "lr": 0.0001, + "sup_loss": 1.2395546664918784 + }, + { + "step": 2614, + "lr": 0.0001, + "sup_loss": 1.3157920437476391 + }, + { + "step": 2615, + "lr": 0.0001, + "sup_loss": 1.2821383600093852 + }, + { + "step": 2616, + "lr": 0.0001, + "sup_loss": 1.254724066414531 + }, + { + "step": 2617, + "lr": 0.0001, + "sup_loss": 1.2765015094135175 + }, + { + "step": 2618, + "lr": 0.0001, + "sup_loss": 1.2221009917192485 + }, + { + "step": 2619, + "lr": 0.0001, + "sup_loss": 1.1918406846055212 + }, + { + "step": 2620, + "lr": 0.0001, + "sup_loss": 1.199919375046413 + }, + { + "step": 2621, + "lr": 0.0001, + "sup_loss": 1.2121639153892665 + }, + { + "step": 2622, + "lr": 0.0001, + "sup_loss": 1.2493638022090487 + }, + { + "step": 2623, + "lr": 0.0001, + "sup_loss": 1.269026483053199 + }, + { + "step": 2624, + "lr": 0.0001, + "sup_loss": 1.1964097100302515 + }, + { + "step": 2625, + "lr": 0.0001, + "sup_loss": 1.227426960907999 + }, + { + "step": 2626, + "lr": 0.0001, + "sup_loss": 1.239799090813128 + }, + { + "step": 2627, + "lr": 0.0001, + "sup_loss": 1.215106039608587 + }, + { + "step": 2628, + "lr": 0.0001, + "sup_loss": 1.2362285599636007 + }, + { + "step": 2629, + "lr": 0.0001, + "sup_loss": 1.2645066298795702 + }, + { + "step": 2630, + "lr": 0.0001, + "sup_loss": 1.2202733650143411 + }, + { + "step": 2631, + "lr": 0.0001, + "sup_loss": 1.193141760689098 + }, + { + "step": 2632, + "lr": 0.0001, + "sup_loss": 1.2199125824204022 + }, + { + "step": 2633, + "lr": 0.0001, + "sup_loss": 1.2497159378308464 + }, + { + "step": 2634, + "lr": 0.0001, + "sup_loss": 1.2403857720403721 + }, + { + "step": 2635, + "lr": 0.0001, + "sup_loss": 1.2408493330085664 + }, + { + "step": 2636, + "lr": 0.0001, + "sup_loss": 1.2050154032179226 + }, + { + "step": 2637, + "lr": 0.0001, + "sup_loss": 1.2207398094125943 + }, + { + "step": 2638, + "lr": 0.0001, + "sup_loss": 1.2335285524949073 + }, + { + "step": 2639, + "lr": 0.0001, + "sup_loss": 1.2272963920441922 + }, + { + "step": 2640, + "lr": 0.0001, + "sup_loss": 1.2512620944172685 + }, + { + "step": 2641, + "lr": 0.0001, + "sup_loss": 1.2681297024570186 + }, + { + "step": 2642, + "lr": 0.0001, + "sup_loss": 1.2275861884123622 + }, + { + "step": 2643, + "lr": 0.0001, + "sup_loss": 1.2321183409350265 + }, + { + "step": 2644, + "lr": 0.0001, + "sup_loss": 1.233677161945556 + }, + { + "step": 2645, + "lr": 0.0001, + "sup_loss": 1.24285375712624 + }, + { + "step": 2646, + "lr": 0.0001, + "sup_loss": 1.229616931781458 + }, + { + "step": 2647, + "lr": 0.0001, + "sup_loss": 1.2251907950513785 + }, + { + "step": 2648, + "lr": 0.0001, + "sup_loss": 1.2131537689713905 + }, + { + "step": 2649, + "lr": 0.0001, + "sup_loss": 1.184480968859997 + }, + { + "step": 2650, + "lr": 0.0001, + "sup_loss": 1.2991780523945282, + "lyap1_mean": -4.168248176574707, + "lyap1_max": -4.102604866027832, + "lyap_spec_mean": [ + -4.168248176574707, + -4.166050910949707 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2651, + "lr": 0.0001, + "sup_loss": 1.2142627714607295 + }, + { + "step": 2652, + "lr": 0.0001, + "sup_loss": 1.2013653125026322 + }, + { + "step": 2653, + "lr": 0.0001, + "sup_loss": 1.2262574699294047 + }, + { + "step": 2654, + "lr": 0.0001, + "sup_loss": 1.2792890708553761 + }, + { + "step": 2655, + "lr": 0.0001, + "sup_loss": 1.2300058791782786 + }, + { + "step": 2656, + "lr": 0.0001, + "sup_loss": 1.2325860259605779 + }, + { + "step": 2657, + "lr": 0.0001, + "sup_loss": 1.2696026453761364 + }, + { + "step": 2658, + "lr": 0.0001, + "sup_loss": 1.25776689775061 + }, + { + "step": 2659, + "lr": 0.0001, + "sup_loss": 1.2688541152812087 + }, + { + "step": 2660, + "lr": 0.0001, + "sup_loss": 1.2317321669170054 + }, + { + "step": 2661, + "lr": 0.0001, + "sup_loss": 1.2573901181549034 + }, + { + "step": 2662, + "lr": 0.0001, + "sup_loss": 1.2595307405289533 + }, + { + "step": 2663, + "lr": 0.0001, + "sup_loss": 1.2617900769054098 + }, + { + "step": 2664, + "lr": 0.0001, + "sup_loss": 1.25702116125521 + }, + { + "step": 2665, + "lr": 0.0001, + "sup_loss": 1.2479849497406827 + }, + { + "step": 2666, + "lr": 0.0001, + "sup_loss": 1.2364926991864176 + }, + { + "step": 2667, + "lr": 0.0001, + "sup_loss": 1.2634144619841137 + }, + { + "step": 2668, + "lr": 0.0001, + "sup_loss": 1.2155289446713848 + }, + { + "step": 2669, + "lr": 0.0001, + "sup_loss": 1.210210627144147 + }, + { + "step": 2670, + "lr": 0.0001, + "sup_loss": 1.2645819816297246 + }, + { + "step": 2671, + "lr": 0.0001, + "sup_loss": 1.1652595961388679 + }, + { + "step": 2672, + "lr": 0.0001, + "sup_loss": 1.2211857736000638 + }, + { + "step": 2673, + "lr": 0.0001, + "sup_loss": 1.1928454166637739 + }, + { + "step": 2674, + "lr": 0.0001, + "sup_loss": 1.2192903549810428 + }, + { + "step": 2675, + "lr": 0.0001, + "sup_loss": 1.2613312822898783 + }, + { + "step": 2676, + "lr": 0.0001, + "sup_loss": 1.2030221459941097 + }, + { + "step": 2677, + "lr": 0.0001, + "sup_loss": 1.1617538199626793 + }, + { + "step": 2678, + "lr": 0.0001, + "sup_loss": 1.2262931189792678 + }, + { + "step": 2679, + "lr": 0.0001, + "sup_loss": 1.2605967333344523 + }, + { + "step": 2680, + "lr": 0.0001, + "sup_loss": 1.1678725193088018 + }, + { + "step": 2681, + "lr": 0.0001, + "sup_loss": 1.238400743383536 + }, + { + "step": 2682, + "lr": 0.0001, + "sup_loss": 1.261504046919922 + }, + { + "step": 2683, + "lr": 0.0001, + "sup_loss": 1.2479996616430884 + }, + { + "step": 2684, + "lr": 0.0001, + "sup_loss": 1.2452577420293118 + }, + { + "step": 2685, + "lr": 0.0001, + "sup_loss": 1.1630908441120917 + }, + { + "step": 2686, + "lr": 0.0001, + "sup_loss": 1.236884288510307 + }, + { + "step": 2687, + "lr": 0.0001, + "sup_loss": 1.257547052127402 + }, + { + "step": 2688, + "lr": 0.0001, + "sup_loss": 1.2389862907354807 + }, + { + "step": 2689, + "lr": 0.0001, + "sup_loss": 1.210508130840378 + }, + { + "step": 2690, + "lr": 0.0001, + "sup_loss": 1.2146456800665766 + }, + { + "step": 2691, + "lr": 0.0001, + "sup_loss": 1.1833097620584363 + }, + { + "step": 2692, + "lr": 0.0001, + "sup_loss": 1.2303068127169816 + }, + { + "step": 2693, + "lr": 0.0001, + "sup_loss": 1.2233629934785821 + }, + { + "step": 2694, + "lr": 0.0001, + "sup_loss": 1.214829726705529 + }, + { + "step": 2695, + "lr": 0.0001, + "sup_loss": 1.1909151715528141 + }, + { + "step": 2696, + "lr": 0.0001, + "sup_loss": 1.2196554054468436 + }, + { + "step": 2697, + "lr": 0.0001, + "sup_loss": 1.2453942550271437 + }, + { + "step": 2698, + "lr": 0.0001, + "sup_loss": 1.209229778147698 + }, + { + "step": 2699, + "lr": 0.0001, + "sup_loss": 1.1766958675207015 + }, + { + "step": 2700, + "lr": 0.0001, + "sup_loss": 1.2198236073581505, + "lyap1_mean": -4.145177364349365, + "lyap1_max": -4.0913896560668945, + "lyap_spec_mean": [ + -4.145176887512207, + -4.136057376861572 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2701, + "lr": 0.0001, + "sup_loss": 1.2880146954173164 + }, + { + "step": 2702, + "lr": 0.0001, + "sup_loss": 1.176585073018046 + }, + { + "step": 2703, + "lr": 0.0001, + "sup_loss": 1.2597035952353128 + }, + { + "step": 2704, + "lr": 0.0001, + "sup_loss": 1.1913034085610907 + }, + { + "step": 2705, + "lr": 0.0001, + "sup_loss": 1.2189204630389974 + }, + { + "step": 2706, + "lr": 0.0001, + "sup_loss": 1.2958042206729246 + }, + { + "step": 2707, + "lr": 0.0001, + "sup_loss": 1.2179067928281493 + }, + { + "step": 2708, + "lr": 0.0001, + "sup_loss": 1.1740395520447249 + }, + { + "step": 2709, + "lr": 0.0001, + "sup_loss": 1.2405722413173224 + }, + { + "step": 2710, + "lr": 0.0001, + "sup_loss": 1.2582204092738973 + }, + { + "step": 2711, + "lr": 0.0001, + "sup_loss": 1.185800269719854 + }, + { + "step": 2712, + "lr": 0.0001, + "sup_loss": 1.2425739850163413 + }, + { + "step": 2713, + "lr": 0.0001, + "sup_loss": 1.2494519796577779 + }, + { + "step": 2714, + "lr": 0.0001, + "sup_loss": 1.1771091277437487 + }, + { + "step": 2715, + "lr": 0.0001, + "sup_loss": 1.23497752042563 + }, + { + "step": 2716, + "lr": 0.0001, + "sup_loss": 1.1898585780165514 + }, + { + "step": 2717, + "lr": 0.0001, + "sup_loss": 1.1633061664767241 + }, + { + "step": 2718, + "lr": 0.0001, + "sup_loss": 1.1796349814599567 + }, + { + "step": 2719, + "lr": 0.0001, + "sup_loss": 1.2305618166506958 + }, + { + "step": 2720, + "lr": 0.0001, + "sup_loss": 1.1893667840347706 + }, + { + "step": 2721, + "lr": 0.0001, + "sup_loss": 1.2037491957803592 + }, + { + "step": 2722, + "lr": 0.0001, + "sup_loss": 1.2198712561133827 + }, + { + "step": 2723, + "lr": 0.0001, + "sup_loss": 1.2329404923248257 + }, + { + "step": 2724, + "lr": 0.0001, + "sup_loss": 1.2189166656131465 + }, + { + "step": 2725, + "lr": 0.0001, + "sup_loss": 1.1933895007474031 + }, + { + "step": 2726, + "lr": 0.0001, + "sup_loss": 1.2004903308178951 + }, + { + "step": 2727, + "lr": 0.0001, + "sup_loss": 1.2152784105541112 + }, + { + "step": 2728, + "lr": 0.0001, + "sup_loss": 1.2430411043509662 + }, + { + "step": 2729, + "lr": 0.0001, + "sup_loss": 1.2199430103046758 + }, + { + "step": 2730, + "lr": 0.0001, + "sup_loss": 1.1434355247339236 + }, + { + "step": 2731, + "lr": 0.0001, + "sup_loss": 1.1955526919386807 + }, + { + "step": 2732, + "lr": 0.0001, + "sup_loss": 1.209411240231424 + }, + { + "step": 2733, + "lr": 0.0001, + "sup_loss": 1.1610627539057328 + }, + { + "step": 2734, + "lr": 0.0001, + "sup_loss": 1.265616125904369 + }, + { + "step": 2735, + "lr": 0.0001, + "sup_loss": 1.233067209210319 + }, + { + "step": 2736, + "lr": 0.0001, + "sup_loss": 1.1349202049704068 + }, + { + "step": 2737, + "lr": 0.0001, + "sup_loss": 1.243318356390707 + }, + { + "step": 2738, + "lr": 0.0001, + "sup_loss": 1.2091210087374296 + }, + { + "step": 2739, + "lr": 0.0001, + "sup_loss": 1.204178753701558 + }, + { + "step": 2740, + "lr": 0.0001, + "sup_loss": 1.2301383137613766 + }, + { + "step": 2741, + "lr": 0.0001, + "sup_loss": 1.194941001323939 + }, + { + "step": 2742, + "lr": 0.0001, + "sup_loss": 1.2801947029592953 + }, + { + "step": 2743, + "lr": 0.0001, + "sup_loss": 1.2673226855160413 + }, + { + "step": 2744, + "lr": 0.0001, + "sup_loss": 1.1574369637623212 + }, + { + "step": 2745, + "lr": 0.0001, + "sup_loss": 1.2059445530420552 + }, + { + "step": 2746, + "lr": 0.0001, + "sup_loss": 1.1969309760339402 + }, + { + "step": 2747, + "lr": 0.0001, + "sup_loss": 1.2148660666052427 + }, + { + "step": 2748, + "lr": 0.0001, + "sup_loss": 1.2679244712600848 + }, + { + "step": 2749, + "lr": 0.0001, + "sup_loss": 1.2099251915517164 + }, + { + "step": 2750, + "lr": 0.0001, + "sup_loss": 1.2394785717424335, + "lyap1_mean": -4.143750190734863, + "lyap1_max": -4.113030433654785, + "lyap_spec_mean": [ + -4.143750190734863, + -4.121489524841309 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2751, + "lr": 0.0001, + "sup_loss": 1.284863019727325 + }, + { + "step": 2752, + "lr": 0.0001, + "sup_loss": 1.233550625109153 + }, + { + "step": 2753, + "lr": 0.0001, + "sup_loss": 1.2208482321052476 + }, + { + "step": 2754, + "lr": 0.0001, + "sup_loss": 1.2380220206520889 + }, + { + "step": 2755, + "lr": 0.0001, + "sup_loss": 1.2261492601117994 + }, + { + "step": 2756, + "lr": 0.0001, + "sup_loss": 1.2237059238576027 + }, + { + "step": 2757, + "lr": 0.0001, + "sup_loss": 1.2285876218270264 + }, + { + "step": 2758, + "lr": 0.0001, + "sup_loss": 1.2275381953624167 + }, + { + "step": 2759, + "lr": 0.0001, + "sup_loss": 1.2361166117305022 + }, + { + "step": 2760, + "lr": 0.0001, + "sup_loss": 1.1846329634607293 + }, + { + "step": 2761, + "lr": 0.0001, + "sup_loss": 1.2236013369391563 + }, + { + "step": 2762, + "lr": 0.0001, + "sup_loss": 1.2273579297738417 + }, + { + "step": 2763, + "lr": 0.0001, + "sup_loss": 1.2187209130458858 + }, + { + "step": 2764, + "lr": 0.0001, + "sup_loss": 1.1774631009643235 + }, + { + "step": 2765, + "lr": 0.0001, + "sup_loss": 1.2236323995349703 + }, + { + "step": 2766, + "lr": 0.0001, + "sup_loss": 1.1818180680383588 + }, + { + "step": 2767, + "lr": 0.0001, + "sup_loss": 1.2034424250363023 + }, + { + "step": 2768, + "lr": 0.0001, + "sup_loss": 1.18371561688779 + }, + { + "step": 2769, + "lr": 0.0001, + "sup_loss": 1.2024557460047902 + }, + { + "step": 2770, + "lr": 0.0001, + "sup_loss": 1.1986742839325801 + }, + { + "step": 2771, + "lr": 0.0001, + "sup_loss": 1.1790561146746892 + }, + { + "step": 2772, + "lr": 0.0001, + "sup_loss": 1.2084146659008368 + }, + { + "step": 2773, + "lr": 0.0001, + "sup_loss": 1.1759226899441422 + }, + { + "step": 2774, + "lr": 0.0001, + "sup_loss": 1.1524661896672563 + }, + { + "step": 2775, + "lr": 0.0001, + "sup_loss": 1.2029550253797614 + }, + { + "step": 2776, + "lr": 0.0001, + "sup_loss": 1.2122894439884144 + }, + { + "step": 2777, + "lr": 0.0001, + "sup_loss": 1.1750197155974214 + }, + { + "step": 2778, + "lr": 0.0001, + "sup_loss": 1.2057003453425166 + }, + { + "step": 2779, + "lr": 0.0001, + "sup_loss": 1.1974536913271807 + }, + { + "step": 2780, + "lr": 0.0001, + "sup_loss": 1.1967415293632362 + }, + { + "step": 2781, + "lr": 0.0001, + "sup_loss": 1.2473728593308882 + }, + { + "step": 2782, + "lr": 0.0001, + "sup_loss": 1.20178185044411 + }, + { + "step": 2783, + "lr": 0.0001, + "sup_loss": 1.1928275692126933 + }, + { + "step": 2784, + "lr": 0.0001, + "sup_loss": 1.1893599898107874 + }, + { + "step": 2785, + "lr": 0.0001, + "sup_loss": 1.1873089050891608 + }, + { + "step": 2786, + "lr": 0.0001, + "sup_loss": 1.2415463692069302 + }, + { + "step": 2787, + "lr": 0.0001, + "sup_loss": 1.2373799716808946 + }, + { + "step": 2788, + "lr": 0.0001, + "sup_loss": 1.1974427804739871 + }, + { + "step": 2789, + "lr": 0.0001, + "sup_loss": 1.1886924107918198 + }, + { + "step": 2790, + "lr": 0.0001, + "sup_loss": 1.1527571170396032 + }, + { + "step": 2791, + "lr": 0.0001, + "sup_loss": 1.1912547398088777 + }, + { + "step": 2792, + "lr": 0.0001, + "sup_loss": 1.2329055287117536 + }, + { + "step": 2793, + "lr": 0.0001, + "sup_loss": 1.2618365797929392 + }, + { + "step": 2794, + "lr": 0.0001, + "sup_loss": 1.1751907376176824 + }, + { + "step": 2795, + "lr": 0.0001, + "sup_loss": 1.1724260160125624 + }, + { + "step": 2796, + "lr": 0.0001, + "sup_loss": 1.2392439352573679 + }, + { + "step": 2797, + "lr": 0.0001, + "sup_loss": 1.209633508685113 + }, + { + "step": 2798, + "lr": 0.0001, + "sup_loss": 1.2019066963454212 + }, + { + "step": 2799, + "lr": 0.0001, + "sup_loss": 1.2139447758952797 + }, + { + "step": 2800, + "lr": 0.0001, + "sup_loss": 1.1932710711203705, + "lyap1_mean": -4.098666667938232, + "lyap1_max": -4.023406505584717, + "lyap_spec_mean": [ + -4.098666667938232, + -4.096119403839111 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2801, + "lr": 0.0001, + "sup_loss": 1.1992359788428548 + }, + { + "step": 2802, + "lr": 0.0001, + "sup_loss": 1.224443586595954 + }, + { + "step": 2803, + "lr": 0.0001, + "sup_loss": 1.1886977014484197 + }, + { + "step": 2804, + "lr": 0.0001, + "sup_loss": 1.2124679468171327 + }, + { + "step": 2805, + "lr": 0.0001, + "sup_loss": 1.226693078449122 + }, + { + "step": 2806, + "lr": 0.0001, + "sup_loss": 1.1944266377460955 + }, + { + "step": 2807, + "lr": 0.0001, + "sup_loss": 1.192333851939071 + }, + { + "step": 2808, + "lr": 0.0001, + "sup_loss": 1.2353895003405737 + }, + { + "step": 2809, + "lr": 0.0001, + "sup_loss": 1.2131763642554134 + }, + { + "step": 2810, + "lr": 0.0001, + "sup_loss": 1.1203792874720453 + }, + { + "step": 2811, + "lr": 0.0001, + "sup_loss": 1.18498464537838 + }, + { + "step": 2812, + "lr": 0.0001, + "sup_loss": 1.207462564988826 + }, + { + "step": 2813, + "lr": 0.0001, + "sup_loss": 1.2474337865979834 + }, + { + "step": 2814, + "lr": 0.0001, + "sup_loss": 1.1924465453378905 + }, + { + "step": 2815, + "lr": 0.0001, + "sup_loss": 1.2341939677174314 + }, + { + "step": 2816, + "lr": 0.0001, + "sup_loss": 1.204472869145486 + }, + { + "step": 2817, + "lr": 0.0001, + "sup_loss": 1.1703876157210666 + }, + { + "step": 2818, + "lr": 0.0001, + "sup_loss": 1.2040041039826734 + }, + { + "step": 2819, + "lr": 0.0001, + "sup_loss": 1.174052402058899 + }, + { + "step": 2820, + "lr": 0.0001, + "sup_loss": 1.1424810811321462 + }, + { + "step": 2821, + "lr": 0.0001, + "sup_loss": 1.1688515694095583 + }, + { + "step": 2822, + "lr": 0.0001, + "sup_loss": 1.1887108821416759 + }, + { + "step": 2823, + "lr": 0.0001, + "sup_loss": 1.1892404297536572 + }, + { + "step": 2824, + "lr": 0.0001, + "sup_loss": 1.2046011036775555 + }, + { + "step": 2825, + "lr": 0.0001, + "sup_loss": 1.1858145615309514 + }, + { + "step": 2826, + "lr": 0.0001, + "sup_loss": 1.1897495943902472 + }, + { + "step": 2827, + "lr": 0.0001, + "sup_loss": 1.1883187262599395 + }, + { + "step": 2828, + "lr": 0.0001, + "sup_loss": 1.2334616058181576 + }, + { + "step": 2829, + "lr": 0.0001, + "sup_loss": 1.2340482098484336 + }, + { + "step": 2830, + "lr": 0.0001, + "sup_loss": 1.262314854804658 + }, + { + "step": 2831, + "lr": 0.0001, + "sup_loss": 1.1894816058362065 + }, + { + "step": 2832, + "lr": 0.0001, + "sup_loss": 1.1948407795911669 + }, + { + "step": 2833, + "lr": 0.0001, + "sup_loss": 1.1159364647106889 + }, + { + "step": 2834, + "lr": 0.0001, + "sup_loss": 1.2129146843921843 + }, + { + "step": 2835, + "lr": 0.0001, + "sup_loss": 1.2269511721615434 + }, + { + "step": 2836, + "lr": 0.0001, + "sup_loss": 1.2122383039764555 + }, + { + "step": 2837, + "lr": 0.0001, + "sup_loss": 1.1458994949785084 + }, + { + "step": 2838, + "lr": 0.0001, + "sup_loss": 1.2040875109310762 + }, + { + "step": 2839, + "lr": 0.0001, + "sup_loss": 1.20474349329665 + }, + { + "step": 2840, + "lr": 0.0001, + "sup_loss": 1.1394442555182653 + }, + { + "step": 2841, + "lr": 0.0001, + "sup_loss": 1.1840842843101966 + }, + { + "step": 2842, + "lr": 0.0001, + "sup_loss": 1.141838865386241 + }, + { + "step": 2843, + "lr": 0.0001, + "sup_loss": 1.16604813166901 + }, + { + "step": 2844, + "lr": 0.0001, + "sup_loss": 1.155479261348026 + }, + { + "step": 2845, + "lr": 0.0001, + "sup_loss": 1.1899330566387052 + }, + { + "step": 2846, + "lr": 0.0001, + "sup_loss": 1.2027384784506403 + }, + { + "step": 2847, + "lr": 0.0001, + "sup_loss": 1.1849872937838002 + }, + { + "step": 2848, + "lr": 0.0001, + "sup_loss": 1.1241586801436854 + }, + { + "step": 2849, + "lr": 0.0001, + "sup_loss": 1.2227660670211045 + }, + { + "step": 2850, + "lr": 0.0001, + "sup_loss": 1.1946299294714526, + "lyap1_mean": -4.078210353851318, + "lyap1_max": -4.034915924072266, + "lyap_spec_mean": [ + -4.07820987701416, + -4.045197010040283 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2851, + "lr": 0.0001, + "sup_loss": 1.2158997966725866 + }, + { + "step": 2852, + "lr": 0.0001, + "sup_loss": 1.1656405885988264 + }, + { + "step": 2853, + "lr": 0.0001, + "sup_loss": 1.155922532205952 + }, + { + "step": 2854, + "lr": 0.0001, + "sup_loss": 1.1890076736471467 + }, + { + "step": 2855, + "lr": 0.0001, + "sup_loss": 1.1692176886947816 + }, + { + "step": 2856, + "lr": 0.0001, + "sup_loss": 1.214723730707917 + }, + { + "step": 2857, + "lr": 0.0001, + "sup_loss": 1.1489284975809753 + }, + { + "step": 2858, + "lr": 0.0001, + "sup_loss": 1.1874928221748196 + }, + { + "step": 2859, + "lr": 0.0001, + "sup_loss": 1.215204873387386 + }, + { + "step": 2860, + "lr": 0.0001, + "sup_loss": 1.1612307816047192 + }, + { + "step": 2861, + "lr": 0.0001, + "sup_loss": 1.1891047610043515 + }, + { + "step": 2862, + "lr": 0.0001, + "sup_loss": 1.2012892688969983 + }, + { + "step": 2863, + "lr": 0.0001, + "sup_loss": 1.1426133608447897 + }, + { + "step": 2864, + "lr": 0.0001, + "sup_loss": 1.1617679128780294 + }, + { + "step": 2865, + "lr": 0.0001, + "sup_loss": 1.1408589656897925 + }, + { + "step": 2866, + "lr": 0.0001, + "sup_loss": 1.146708760416167 + }, + { + "step": 2867, + "lr": 0.0001, + "sup_loss": 1.1684592155412288 + }, + { + "step": 2868, + "lr": 0.0001, + "sup_loss": 1.1647948119819325 + }, + { + "step": 2869, + "lr": 0.0001, + "sup_loss": 1.1751339515984083 + }, + { + "step": 2870, + "lr": 0.0001, + "sup_loss": 1.1939843035738116 + }, + { + "step": 2871, + "lr": 0.0001, + "sup_loss": 1.152120812532805 + }, + { + "step": 2872, + "lr": 0.0001, + "sup_loss": 1.1790699006620267 + }, + { + "step": 2873, + "lr": 0.0001, + "sup_loss": 1.1816362228296602 + }, + { + "step": 2874, + "lr": 0.0001, + "sup_loss": 1.154230955305328 + }, + { + "step": 2875, + "lr": 0.0001, + "sup_loss": 1.1869670145034565 + }, + { + "step": 2876, + "lr": 0.0001, + "sup_loss": 1.198217257954748 + }, + { + "step": 2877, + "lr": 0.0001, + "sup_loss": 1.178907155494454 + }, + { + "step": 2878, + "lr": 0.0001, + "sup_loss": 1.200648403269875 + }, + { + "step": 2879, + "lr": 0.0001, + "sup_loss": 1.1860254880272565 + }, + { + "step": 2880, + "lr": 0.0001, + "sup_loss": 1.1733465436563406 + }, + { + "step": 2881, + "lr": 0.0001, + "sup_loss": 1.096949323573581 + }, + { + "step": 2882, + "lr": 0.0001, + "sup_loss": 1.1242257301280816 + }, + { + "step": 2883, + "lr": 0.0001, + "sup_loss": 1.1987406168920336 + }, + { + "step": 2884, + "lr": 0.0001, + "sup_loss": 1.1899407768330346 + }, + { + "step": 2885, + "lr": 0.0001, + "sup_loss": 1.1901822490716116 + }, + { + "step": 2886, + "lr": 0.0001, + "sup_loss": 1.1889308342205704 + }, + { + "step": 2887, + "lr": 0.0001, + "sup_loss": 1.207253840898637 + }, + { + "step": 2888, + "lr": 0.0001, + "sup_loss": 1.0427842523974111 + }, + { + "step": 2889, + "lr": 0.0001, + "sup_loss": 1.252588670479281 + }, + { + "step": 2890, + "lr": 0.0001, + "sup_loss": 1.18839651161764 + }, + { + "step": 2891, + "lr": 0.0001, + "sup_loss": 1.132269866290512 + }, + { + "step": 2892, + "lr": 0.0001, + "sup_loss": 1.1798659901783823 + }, + { + "step": 2893, + "lr": 0.0001, + "sup_loss": 1.1298951990330095 + }, + { + "step": 2894, + "lr": 0.0001, + "sup_loss": 1.1971495758809165 + }, + { + "step": 2895, + "lr": 0.0001, + "sup_loss": 1.1781393181666764 + }, + { + "step": 2896, + "lr": 0.0001, + "sup_loss": 1.200866593014584 + }, + { + "step": 2897, + "lr": 0.0001, + "sup_loss": 1.2609272796460058 + }, + { + "step": 2898, + "lr": 0.0001, + "sup_loss": 1.1340103707874907 + }, + { + "step": 2899, + "lr": 0.0001, + "sup_loss": 1.1758957142742377 + }, + { + "step": 2900, + "lr": 0.0001, + "sup_loss": 1.2324421750710768, + "lyap1_mean": -4.075942039489746, + "lyap1_max": -4.031743049621582, + "lyap_spec_mean": [ + -4.075942039489746, + -4.056901931762695 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2901, + "lr": 0.0001, + "sup_loss": 1.2187291516481937 + }, + { + "step": 2902, + "lr": 0.0001, + "sup_loss": 1.2261938936775971 + }, + { + "step": 2903, + "lr": 0.0001, + "sup_loss": 1.1872528217774525 + }, + { + "step": 2904, + "lr": 0.0001, + "sup_loss": 1.188666017764403 + }, + { + "step": 2905, + "lr": 0.0001, + "sup_loss": 1.1238364290538336 + }, + { + "step": 2906, + "lr": 0.0001, + "sup_loss": 1.1120989900587106 + }, + { + "step": 2907, + "lr": 0.0001, + "sup_loss": 1.2277774401355726 + }, + { + "step": 2908, + "lr": 0.0001, + "sup_loss": 1.1857180597484058 + }, + { + "step": 2909, + "lr": 0.0001, + "sup_loss": 1.1795244650958037 + }, + { + "step": 2910, + "lr": 0.0001, + "sup_loss": 1.1669530044039547 + }, + { + "step": 2911, + "lr": 0.0001, + "sup_loss": 1.1706363013080479 + }, + { + "step": 2912, + "lr": 0.0001, + "sup_loss": 1.100990712193374 + }, + { + "step": 2913, + "lr": 0.0001, + "sup_loss": 1.1588804353463202 + }, + { + "step": 2914, + "lr": 0.0001, + "sup_loss": 1.2126128018682034 + }, + { + "step": 2915, + "lr": 0.0001, + "sup_loss": 1.1778418880363921 + }, + { + "step": 2916, + "lr": 0.0001, + "sup_loss": 1.155806804963178 + }, + { + "step": 2917, + "lr": 0.0001, + "sup_loss": 1.1762411167879385 + }, + { + "step": 2918, + "lr": 0.0001, + "sup_loss": 1.1179291698849965 + }, + { + "step": 2919, + "lr": 0.0001, + "sup_loss": 1.170109204444336 + }, + { + "step": 2920, + "lr": 0.0001, + "sup_loss": 1.1981055816241923 + }, + { + "step": 2921, + "lr": 0.0001, + "sup_loss": 1.17888707374863 + }, + { + "step": 2922, + "lr": 0.0001, + "sup_loss": 1.2015338757936609 + }, + { + "step": 2923, + "lr": 0.0001, + "sup_loss": 1.1444368246317362 + }, + { + "step": 2924, + "lr": 0.0001, + "sup_loss": 1.150511402385754 + }, + { + "step": 2925, + "lr": 0.0001, + "sup_loss": 1.1897001767833921 + }, + { + "step": 2926, + "lr": 0.0001, + "sup_loss": 1.197184738845019 + }, + { + "step": 2927, + "lr": 0.0001, + "sup_loss": 1.1928740911563882 + }, + { + "step": 2928, + "lr": 0.0001, + "sup_loss": 1.1444655352074873 + }, + { + "step": 2929, + "lr": 0.0001, + "sup_loss": 1.1625666361192932 + }, + { + "step": 2930, + "lr": 0.0001, + "sup_loss": 1.1688287682219136 + }, + { + "step": 2931, + "lr": 0.0001, + "sup_loss": 1.1409571925999333 + }, + { + "step": 2932, + "lr": 0.0001, + "sup_loss": 1.1979738588901685 + }, + { + "step": 2933, + "lr": 0.0001, + "sup_loss": 1.136123197871838 + }, + { + "step": 2934, + "lr": 0.0001, + "sup_loss": 1.2242667976317398 + }, + { + "step": 2935, + "lr": 0.0001, + "sup_loss": 1.173073780174113 + }, + { + "step": 2936, + "lr": 0.0001, + "sup_loss": 1.157782913928542 + }, + { + "step": 2937, + "lr": 0.0001, + "sup_loss": 1.2040865487659438 + }, + { + "step": 2938, + "lr": 0.0001, + "sup_loss": 1.1856106809552456 + }, + { + "step": 2939, + "lr": 0.0001, + "sup_loss": 1.1675539629425669 + }, + { + "step": 2940, + "lr": 0.0001, + "sup_loss": 1.1483279284979238 + }, + { + "step": 2941, + "lr": 0.0001, + "sup_loss": 1.1564708697313058 + }, + { + "step": 2942, + "lr": 0.0001, + "sup_loss": 1.2134473587962367 + }, + { + "step": 2943, + "lr": 0.0001, + "sup_loss": 1.1816269042600522 + }, + { + "step": 2944, + "lr": 0.0001, + "sup_loss": 1.1426613519069986 + }, + { + "step": 2945, + "lr": 0.0001, + "sup_loss": 1.1792052165579912 + }, + { + "step": 2946, + "lr": 0.0001, + "sup_loss": 1.167843994471431 + }, + { + "step": 2947, + "lr": 0.0001, + "sup_loss": 1.183089975029637 + }, + { + "step": 2948, + "lr": 0.0001, + "sup_loss": 1.170864852254815 + }, + { + "step": 2949, + "lr": 0.0001, + "sup_loss": 1.1590587537602042 + }, + { + "step": 2950, + "lr": 0.0001, + "sup_loss": 1.1370805382976412, + "lyap1_mean": -4.0443925857543945, + "lyap1_max": -3.981407642364502, + "lyap_spec_mean": [ + -4.0443925857543945, + -4.064511299133301 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2951, + "lr": 0.0001, + "sup_loss": 1.1491813169557314 + }, + { + "step": 2952, + "lr": 0.0001, + "sup_loss": 1.1615139663771925 + }, + { + "step": 2953, + "lr": 0.0001, + "sup_loss": 1.1525536184712686 + }, + { + "step": 2954, + "lr": 0.0001, + "sup_loss": 1.1680880258820185 + }, + { + "step": 2955, + "lr": 0.0001, + "sup_loss": 1.2009458917465787 + }, + { + "step": 2956, + "lr": 0.0001, + "sup_loss": 1.1734697854098128 + }, + { + "step": 2957, + "lr": 0.0001, + "sup_loss": 1.1449008867426098 + }, + { + "step": 2958, + "lr": 0.0001, + "sup_loss": 1.1457298844734047 + }, + { + "step": 2959, + "lr": 0.0001, + "sup_loss": 1.148402188629566 + }, + { + "step": 2960, + "lr": 0.0001, + "sup_loss": 1.147558309889396 + }, + { + "step": 2961, + "lr": 0.0001, + "sup_loss": 1.1788514939392485 + }, + { + "step": 2962, + "lr": 0.0001, + "sup_loss": 1.190776967578652 + }, + { + "step": 2963, + "lr": 0.0001, + "sup_loss": 1.1768656677437581 + }, + { + "step": 2964, + "lr": 0.0001, + "sup_loss": 1.196892056701697 + }, + { + "step": 2965, + "lr": 0.0001, + "sup_loss": 1.1571320471255018 + }, + { + "step": 2966, + "lr": 0.0001, + "sup_loss": 1.1264738882019996 + }, + { + "step": 2967, + "lr": 0.0001, + "sup_loss": 1.1526100889005635 + }, + { + "step": 2968, + "lr": 0.0001, + "sup_loss": 1.163735278966188 + }, + { + "step": 2969, + "lr": 0.0001, + "sup_loss": 1.2055233338188271 + }, + { + "step": 2970, + "lr": 0.0001, + "sup_loss": 1.1285352656067338 + }, + { + "step": 2971, + "lr": 0.0001, + "sup_loss": 1.1858702061614081 + }, + { + "step": 2972, + "lr": 0.0001, + "sup_loss": 1.1757114354599536 + }, + { + "step": 2973, + "lr": 0.0001, + "sup_loss": 1.1392801986571524 + }, + { + "step": 2974, + "lr": 0.0001, + "sup_loss": 1.1286656941304138 + }, + { + "step": 2975, + "lr": 0.0001, + "sup_loss": 1.158593817334657 + }, + { + "step": 2976, + "lr": 0.0001, + "sup_loss": 1.117415718219704 + }, + { + "step": 2977, + "lr": 0.0001, + "sup_loss": 1.1336880365905515 + }, + { + "step": 2978, + "lr": 0.0001, + "sup_loss": 1.1900292231288252 + }, + { + "step": 2979, + "lr": 0.0001, + "sup_loss": 1.1893053077115456 + }, + { + "step": 2980, + "lr": 0.0001, + "sup_loss": 1.1652481772555807 + }, + { + "step": 2981, + "lr": 0.0001, + "sup_loss": 1.174186948480565 + }, + { + "step": 2982, + "lr": 0.0001, + "sup_loss": 1.1269489485253894 + }, + { + "step": 2983, + "lr": 0.0001, + "sup_loss": 1.1743589914590937 + }, + { + "step": 2984, + "lr": 0.0001, + "sup_loss": 1.1596524248955662 + }, + { + "step": 2985, + "lr": 0.0001, + "sup_loss": 1.0697048282521715 + }, + { + "step": 2986, + "lr": 0.0001, + "sup_loss": 1.1886016550622456 + }, + { + "step": 2987, + "lr": 0.0001, + "sup_loss": 1.1834043850315474 + }, + { + "step": 2988, + "lr": 0.0001, + "sup_loss": 1.1675571433591352 + }, + { + "step": 2989, + "lr": 0.0001, + "sup_loss": 1.1720413201939002 + }, + { + "step": 2990, + "lr": 0.0001, + "sup_loss": 1.1959874962050194 + }, + { + "step": 2991, + "lr": 0.0001, + "sup_loss": 1.1215594680166399 + }, + { + "step": 2992, + "lr": 0.0001, + "sup_loss": 1.1600075908147822 + }, + { + "step": 2993, + "lr": 0.0001, + "sup_loss": 1.1364626191809135 + }, + { + "step": 2994, + "lr": 0.0001, + "sup_loss": 1.2316981120958004 + }, + { + "step": 2995, + "lr": 0.0001, + "sup_loss": 1.1565516832981928 + }, + { + "step": 2996, + "lr": 0.0001, + "sup_loss": 1.1648822632412152 + }, + { + "step": 2997, + "lr": 0.0001, + "sup_loss": 1.0539961582229516 + }, + { + "step": 2998, + "lr": 0.0001, + "sup_loss": 1.144950537758599 + }, + { + "step": 2999, + "lr": 0.0001, + "sup_loss": 1.1471636485820178 + } + ], + "evals": [ + { + "step": 0, + "acc": 0.0, + "tok_acc": 0.11108699845679013 + }, + { + "step": 300, + "acc": 0.0, + "tok_acc": 0.38797260802469136 + }, + { + "step": 600, + "acc": 0.0, + "tok_acc": 0.38915412808641975 + }, + { + "step": 900, + "acc": 0.0, + "tok_acc": 0.40340470679012347 + }, + { + "step": 1200, + "acc": 0.0, + "tok_acc": 0.4230324074074074 + }, + { + "step": 1500, + "acc": 0.0, + "tok_acc": 0.4381269290123457 + }, + { + "step": 1800, + "acc": 0.0, + "tok_acc": 0.45703125 + }, + { + "step": 2100, + "acc": 0.0, + "tok_acc": 0.47528452932098764 + }, + { + "step": 2400, + "acc": 0.0, + "tok_acc": 0.49129533179012347 + }, + { + "step": 2700, + "acc": 0.0, + "tok_acc": 0.5081018518518519 + }, + { + "step": 3000, + "acc": 0.0, + "tok_acc": 0.5225935570987654 + } + ], + "final_acc": 0.0, + "final_tok_acc": 0.5225935570987654 +}
\ No newline at end of file diff --git a/srm/runs/srm_smoke_500_h256.json b/srm/runs/srm_smoke_500_h256.json new file mode 100644 index 0000000..728ef05 --- /dev/null +++ b/srm/runs/srm_smoke_500_h256.json @@ -0,0 +1,2712 @@ +{ + "args": { + "data_path": "/home/yurenh2/rrm/data/sudoku-extreme-1k-aug-1000", + "n_steps": 500, + "batch_size": 8, + "lr": 0.0001, + "puzzle_emb_lr": 0.0001, + "warmup_steps": 100, + "weight_decay": 1.0, + "hidden_size": 256, + "n_iters": 6, + "n_aol_layers": 2, + "kappa": 0.9, + "eta": 1.0, + "alpha": 1.0, + "k_lyap": 2, + "lyap_iters": 4, + "lyap_every": 25, + "seed": 42, + "eval_every": 100, + "eval_n": 256, + "eval_batch_size": 32, + "out": "runs/srm_smoke_500_h256.json", + "save_ckpt": "" + }, + "n_params": 939314, + "initial_acc": 0.0, + "initial_tok_acc": 0.0, + "initial_lip": { + "lip_emp_mean": 0.1357038915157318, + "lip_emp_max": 0.17765390872955322, + "lip_emp_99p": 0.17537692189216614, + "lip_theoretical_bound": 0.9, + "passes_bound": true + }, + "steps": [ + { + "step": 0, + "lr": 0.0, + "sup_loss": 2.8284496844095326, + "lyap1_mean": -6.2286057472229, + "lyap1_max": -6.200310230255127, + "lyap_spec_mean": [ + -6.2286057472229, + -6.228340148925781 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1, + "lr": 1e-06, + "sup_loss": 2.838926445513094 + }, + { + "step": 2, + "lr": 2e-06, + "sup_loss": 2.834020958290193 + }, + { + "step": 3, + "lr": 3e-06, + "sup_loss": 2.8271419600543934 + }, + { + "step": 4, + "lr": 4e-06, + "sup_loss": 2.8336220039837565 + }, + { + "step": 5, + "lr": 5e-06, + "sup_loss": 2.847244138413309 + }, + { + "step": 6, + "lr": 6e-06, + "sup_loss": 2.8296374251845307 + }, + { + "step": 7, + "lr": 7e-06, + "sup_loss": 2.816413976469476 + }, + { + "step": 8, + "lr": 8e-06, + "sup_loss": 2.8221126965976864 + }, + { + "step": 9, + "lr": 9e-06, + "sup_loss": 2.8106848008287297 + }, + { + "step": 10, + "lr": 1e-05, + "sup_loss": 2.8203775573541052 + }, + { + "step": 11, + "lr": 1.1000000000000001e-05, + "sup_loss": 2.8181432855784427 + }, + { + "step": 12, + "lr": 1.2e-05, + "sup_loss": 2.8234647595703923 + }, + { + "step": 13, + "lr": 1.3000000000000001e-05, + "sup_loss": 2.819964976625202 + }, + { + "step": 14, + "lr": 1.4e-05, + "sup_loss": 2.777240835924918 + }, + { + "step": 15, + "lr": 1.5e-05, + "sup_loss": 2.796632874074624 + }, + { + "step": 16, + "lr": 1.6e-05, + "sup_loss": 2.80353484864027 + }, + { + "step": 17, + "lr": 1.7e-05, + "sup_loss": 2.7731115467511405 + }, + { + "step": 18, + "lr": 1.8e-05, + "sup_loss": 2.776553477441689 + }, + { + "step": 19, + "lr": 1.9e-05, + "sup_loss": 2.764454348935523 + }, + { + "step": 20, + "lr": 2e-05, + "sup_loss": 2.763660193795498 + }, + { + "step": 21, + "lr": 2.1000000000000002e-05, + "sup_loss": 2.7644818192133025 + }, + { + "step": 22, + "lr": 2.2000000000000003e-05, + "sup_loss": 2.720537518373678 + }, + { + "step": 23, + "lr": 2.3e-05, + "sup_loss": 2.7332803327454616 + }, + { + "step": 24, + "lr": 2.4e-05, + "sup_loss": 2.7274532837280776 + }, + { + "step": 25, + "lr": 2.5e-05, + "sup_loss": 2.7009521547955337, + "lyap1_mean": -6.240983009338379, + "lyap1_max": -6.22477388381958, + "lyap_spec_mean": [ + -6.240983009338379, + -6.240518093109131 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 26, + "lr": 2.6000000000000002e-05, + "sup_loss": 2.7118575888452168 + }, + { + "step": 27, + "lr": 2.7000000000000002e-05, + "sup_loss": 2.676175428796176 + }, + { + "step": 28, + "lr": 2.8e-05, + "sup_loss": 2.693807866858765 + }, + { + "step": 29, + "lr": 2.9000000000000004e-05, + "sup_loss": 2.682955672998549 + }, + { + "step": 30, + "lr": 3e-05, + "sup_loss": 2.654173913401533 + }, + { + "step": 31, + "lr": 3.1e-05, + "sup_loss": 2.6763871059258495 + }, + { + "step": 32, + "lr": 3.2e-05, + "sup_loss": 2.644394835134615 + }, + { + "step": 33, + "lr": 3.3e-05, + "sup_loss": 2.6299395433077652 + }, + { + "step": 34, + "lr": 3.4e-05, + "sup_loss": 2.6242866722739664 + }, + { + "step": 35, + "lr": 3.5000000000000004e-05, + "sup_loss": 2.616557927761839 + }, + { + "step": 36, + "lr": 3.6e-05, + "sup_loss": 2.5994089813723797 + }, + { + "step": 37, + "lr": 3.7000000000000005e-05, + "sup_loss": 2.5626432829550247 + }, + { + "step": 38, + "lr": 3.8e-05, + "sup_loss": 2.5606932168456327 + }, + { + "step": 39, + "lr": 3.9e-05, + "sup_loss": 2.546780039790928 + }, + { + "step": 40, + "lr": 4e-05, + "sup_loss": 2.520369392127516 + }, + { + "step": 41, + "lr": 4.1e-05, + "sup_loss": 2.5127611686076583 + }, + { + "step": 42, + "lr": 4.2000000000000004e-05, + "sup_loss": 2.5208038257044745 + }, + { + "step": 43, + "lr": 4.3e-05, + "sup_loss": 2.493714124425292 + }, + { + "step": 44, + "lr": 4.4000000000000006e-05, + "sup_loss": 2.480158985877274 + }, + { + "step": 45, + "lr": 4.5e-05, + "sup_loss": 2.4361940027334783 + }, + { + "step": 46, + "lr": 4.6e-05, + "sup_loss": 2.4460679490083947 + }, + { + "step": 47, + "lr": 4.7000000000000004e-05, + "sup_loss": 2.4495761120800132 + }, + { + "step": 48, + "lr": 4.8e-05, + "sup_loss": 2.4131285345159026 + }, + { + "step": 49, + "lr": 4.9e-05, + "sup_loss": 2.3999822324103657 + }, + { + "step": 50, + "lr": 5e-05, + "sup_loss": 2.4029195286821534, + "lyap1_mean": -6.2544169425964355, + "lyap1_max": -6.231961250305176, + "lyap_spec_mean": [ + -6.2544169425964355, + -6.252962112426758 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 51, + "lr": 5.1000000000000006e-05, + "sup_loss": 2.366847464160111 + }, + { + "step": 52, + "lr": 5.2000000000000004e-05, + "sup_loss": 2.33094637470472 + }, + { + "step": 53, + "lr": 5.3e-05, + "sup_loss": 2.329777112486255 + }, + { + "step": 54, + "lr": 5.4000000000000005e-05, + "sup_loss": 2.334095543782154 + }, + { + "step": 55, + "lr": 5.500000000000001e-05, + "sup_loss": 2.3051139076185523 + }, + { + "step": 56, + "lr": 5.6e-05, + "sup_loss": 2.3167502882455797 + }, + { + "step": 57, + "lr": 5.7e-05, + "sup_loss": 2.2903970820408137 + }, + { + "step": 58, + "lr": 5.800000000000001e-05, + "sup_loss": 2.274886117171231 + }, + { + "step": 59, + "lr": 5.9e-05, + "sup_loss": 2.2313597888611825 + }, + { + "step": 60, + "lr": 6e-05, + "sup_loss": 2.2339985174568273 + }, + { + "step": 61, + "lr": 6.1000000000000005e-05, + "sup_loss": 2.223536861505 + }, + { + "step": 62, + "lr": 6.2e-05, + "sup_loss": 2.201599151730311 + }, + { + "step": 63, + "lr": 6.3e-05, + "sup_loss": 2.1832543882469557 + }, + { + "step": 64, + "lr": 6.4e-05, + "sup_loss": 2.1580907568451795 + }, + { + "step": 65, + "lr": 6.500000000000001e-05, + "sup_loss": 2.1679979832095837 + }, + { + "step": 66, + "lr": 6.6e-05, + "sup_loss": 2.151159814374817 + }, + { + "step": 67, + "lr": 6.7e-05, + "sup_loss": 2.132176910649508 + }, + { + "step": 68, + "lr": 6.8e-05, + "sup_loss": 2.123453724015459 + }, + { + "step": 69, + "lr": 6.900000000000001e-05, + "sup_loss": 2.100389289485579 + }, + { + "step": 70, + "lr": 7.000000000000001e-05, + "sup_loss": 2.100101099728348 + }, + { + "step": 71, + "lr": 7.1e-05, + "sup_loss": 2.082929395622361 + }, + { + "step": 72, + "lr": 7.2e-05, + "sup_loss": 2.0613085193351983 + }, + { + "step": 73, + "lr": 7.3e-05, + "sup_loss": 2.043758664648479 + }, + { + "step": 74, + "lr": 7.400000000000001e-05, + "sup_loss": 2.0471150778750125 + }, + { + "step": 75, + "lr": 7.500000000000001e-05, + "sup_loss": 2.043438499353482, + "lyap1_mean": -6.26137638092041, + "lyap1_max": -6.241876125335693, + "lyap_spec_mean": [ + -6.261376857757568, + -6.260560035705566 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 76, + "lr": 7.6e-05, + "sup_loss": 2.0290594292513395 + }, + { + "step": 77, + "lr": 7.7e-05, + "sup_loss": 2.017350256019743 + }, + { + "step": 78, + "lr": 7.8e-05, + "sup_loss": 2.010315789581182 + }, + { + "step": 79, + "lr": 7.900000000000001e-05, + "sup_loss": 2.007747901168263 + }, + { + "step": 80, + "lr": 8e-05, + "sup_loss": 1.9878722973916485 + }, + { + "step": 81, + "lr": 8.099999999999999e-05, + "sup_loss": 1.9820387430330704 + }, + { + "step": 82, + "lr": 8.2e-05, + "sup_loss": 1.960933098122315 + }, + { + "step": 83, + "lr": 8.3e-05, + "sup_loss": 1.9703326768508003 + }, + { + "step": 84, + "lr": 8.400000000000001e-05, + "sup_loss": 1.9608279961175652 + }, + { + "step": 85, + "lr": 8.5e-05, + "sup_loss": 1.9439071529032013 + }, + { + "step": 86, + "lr": 8.6e-05, + "sup_loss": 1.940231741846871 + }, + { + "step": 87, + "lr": 8.700000000000001e-05, + "sup_loss": 1.9256818466494516 + }, + { + "step": 88, + "lr": 8.800000000000001e-05, + "sup_loss": 1.9422044059735057 + }, + { + "step": 89, + "lr": 8.9e-05, + "sup_loss": 1.9265779568349395 + }, + { + "step": 90, + "lr": 9e-05, + "sup_loss": 1.9107046426157344 + }, + { + "step": 91, + "lr": 9.1e-05, + "sup_loss": 1.9120888307606432 + }, + { + "step": 92, + "lr": 9.2e-05, + "sup_loss": 1.9039226834805385 + }, + { + "step": 93, + "lr": 9.300000000000001e-05, + "sup_loss": 1.8859638864585686 + }, + { + "step": 94, + "lr": 9.400000000000001e-05, + "sup_loss": 1.8935103237832633 + }, + { + "step": 95, + "lr": 9.499999999999999e-05, + "sup_loss": 1.8780442206074615 + }, + { + "step": 96, + "lr": 9.6e-05, + "sup_loss": 1.880738136494954 + }, + { + "step": 97, + "lr": 9.7e-05, + "sup_loss": 1.8727563337733835 + }, + { + "step": 98, + "lr": 9.8e-05, + "sup_loss": 1.8747788248049444 + }, + { + "step": 99, + "lr": 9.900000000000001e-05, + "sup_loss": 1.8535151587817753 + }, + { + "step": 100, + "lr": 0.0001, + "sup_loss": 1.8369216468190068, + "lyap1_mean": -6.2764668464660645, + "lyap1_max": -6.253869533538818, + "lyap_spec_mean": [ + -6.2764668464660645, + -6.276641368865967 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 101, + "lr": 0.0001, + "sup_loss": 1.8375981252343498 + }, + { + "step": 102, + "lr": 0.0001, + "sup_loss": 1.8414441493027138 + }, + { + "step": 103, + "lr": 0.0001, + "sup_loss": 1.841932872396079 + }, + { + "step": 104, + "lr": 0.0001, + "sup_loss": 1.8250621869367878 + }, + { + "step": 105, + "lr": 0.0001, + "sup_loss": 1.8180236366243632 + }, + { + "step": 106, + "lr": 0.0001, + "sup_loss": 1.8148333969430548 + }, + { + "step": 107, + "lr": 0.0001, + "sup_loss": 1.8097191971601063 + }, + { + "step": 108, + "lr": 0.0001, + "sup_loss": 1.8062571266936345 + }, + { + "step": 109, + "lr": 0.0001, + "sup_loss": 1.783310944279242 + }, + { + "step": 110, + "lr": 0.0001, + "sup_loss": 1.7882709675762618 + }, + { + "step": 111, + "lr": 0.0001, + "sup_loss": 1.7837487501971951 + }, + { + "step": 112, + "lr": 0.0001, + "sup_loss": 1.8040981386613326 + }, + { + "step": 113, + "lr": 0.0001, + "sup_loss": 1.7839348955084138 + }, + { + "step": 114, + "lr": 0.0001, + "sup_loss": 1.7808710490288988 + }, + { + "step": 115, + "lr": 0.0001, + "sup_loss": 1.73568023182333 + }, + { + "step": 116, + "lr": 0.0001, + "sup_loss": 1.7546620469313183 + }, + { + "step": 117, + "lr": 0.0001, + "sup_loss": 1.7751414856763805 + }, + { + "step": 118, + "lr": 0.0001, + "sup_loss": 1.752759060218006 + }, + { + "step": 119, + "lr": 0.0001, + "sup_loss": 1.7358692128944557 + }, + { + "step": 120, + "lr": 0.0001, + "sup_loss": 1.739228786343244 + }, + { + "step": 121, + "lr": 0.0001, + "sup_loss": 1.7493239323825307 + }, + { + "step": 122, + "lr": 0.0001, + "sup_loss": 1.7536705840390145 + }, + { + "step": 123, + "lr": 0.0001, + "sup_loss": 1.7502938192568702 + }, + { + "step": 124, + "lr": 0.0001, + "sup_loss": 1.7474968410988128 + }, + { + "step": 125, + "lr": 0.0001, + "sup_loss": 1.741263138180546, + "lyap1_mean": -6.289633750915527, + "lyap1_max": -6.271181106567383, + "lyap_spec_mean": [ + -6.289633750915527, + -6.290492534637451 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 126, + "lr": 0.0001, + "sup_loss": 1.7211279276855354 + }, + { + "step": 127, + "lr": 0.0001, + "sup_loss": 1.7073139543990044 + }, + { + "step": 128, + "lr": 0.0001, + "sup_loss": 1.7141654935069126 + }, + { + "step": 129, + "lr": 0.0001, + "sup_loss": 1.7005028367708452 + }, + { + "step": 130, + "lr": 0.0001, + "sup_loss": 1.6860979041501705 + }, + { + "step": 131, + "lr": 0.0001, + "sup_loss": 1.7066609179775223 + }, + { + "step": 132, + "lr": 0.0001, + "sup_loss": 1.6979615420852867 + }, + { + "step": 133, + "lr": 0.0001, + "sup_loss": 1.7273194417800906 + }, + { + "step": 134, + "lr": 0.0001, + "sup_loss": 1.7047646668485257 + }, + { + "step": 135, + "lr": 0.0001, + "sup_loss": 1.716210852207255 + }, + { + "step": 136, + "lr": 0.0001, + "sup_loss": 1.7307658980947846 + }, + { + "step": 137, + "lr": 0.0001, + "sup_loss": 1.711602512894522 + }, + { + "step": 138, + "lr": 0.0001, + "sup_loss": 1.7057358493816908 + }, + { + "step": 139, + "lr": 0.0001, + "sup_loss": 1.688446466585652 + }, + { + "step": 140, + "lr": 0.0001, + "sup_loss": 1.704572577683926 + }, + { + "step": 141, + "lr": 0.0001, + "sup_loss": 1.7304753449546095 + }, + { + "step": 142, + "lr": 0.0001, + "sup_loss": 1.6883580864485974 + }, + { + "step": 143, + "lr": 0.0001, + "sup_loss": 1.6718549694522848 + }, + { + "step": 144, + "lr": 0.0001, + "sup_loss": 1.7193390482772282 + }, + { + "step": 145, + "lr": 0.0001, + "sup_loss": 1.6713528463158704 + }, + { + "step": 146, + "lr": 0.0001, + "sup_loss": 1.6959659224268964 + }, + { + "step": 147, + "lr": 0.0001, + "sup_loss": 1.6890260775715398 + }, + { + "step": 148, + "lr": 0.0001, + "sup_loss": 1.6248832250680991 + }, + { + "step": 149, + "lr": 0.0001, + "sup_loss": 1.654215549400142 + }, + { + "step": 150, + "lr": 0.0001, + "sup_loss": 1.6615707449121377, + "lyap1_mean": -6.306196689605713, + "lyap1_max": -6.2920122146606445, + "lyap_spec_mean": [ + -6.306196212768555, + -6.305814266204834 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 151, + "lr": 0.0001, + "sup_loss": 1.6810928502731424 + }, + { + "step": 152, + "lr": 0.0001, + "sup_loss": 1.6695774965144798 + }, + { + "step": 153, + "lr": 0.0001, + "sup_loss": 1.6444260938397506 + }, + { + "step": 154, + "lr": 0.0001, + "sup_loss": 1.6821734376746678 + }, + { + "step": 155, + "lr": 0.0001, + "sup_loss": 1.6728631290634948 + }, + { + "step": 156, + "lr": 0.0001, + "sup_loss": 1.6820655261417026 + }, + { + "step": 157, + "lr": 0.0001, + "sup_loss": 1.6516146373078011 + }, + { + "step": 158, + "lr": 0.0001, + "sup_loss": 1.6530359901341733 + }, + { + "step": 159, + "lr": 0.0001, + "sup_loss": 1.684539741706318 + }, + { + "step": 160, + "lr": 0.0001, + "sup_loss": 1.6740305810886589 + }, + { + "step": 161, + "lr": 0.0001, + "sup_loss": 1.60870367198615 + }, + { + "step": 162, + "lr": 0.0001, + "sup_loss": 1.6475936644805484 + }, + { + "step": 163, + "lr": 0.0001, + "sup_loss": 1.6515501185205237 + }, + { + "step": 164, + "lr": 0.0001, + "sup_loss": 1.6180064545910822 + }, + { + "step": 165, + "lr": 0.0001, + "sup_loss": 1.6406713466514131 + }, + { + "step": 166, + "lr": 0.0001, + "sup_loss": 1.6452356602937375 + }, + { + "step": 167, + "lr": 0.0001, + "sup_loss": 1.6201243770891205 + }, + { + "step": 168, + "lr": 0.0001, + "sup_loss": 1.665671342076336 + }, + { + "step": 169, + "lr": 0.0001, + "sup_loss": 1.6228934612102783 + }, + { + "step": 170, + "lr": 0.0001, + "sup_loss": 1.6389439525875207 + }, + { + "step": 171, + "lr": 0.0001, + "sup_loss": 1.6387175869530952 + }, + { + "step": 172, + "lr": 0.0001, + "sup_loss": 1.6356821068128287 + }, + { + "step": 173, + "lr": 0.0001, + "sup_loss": 1.6217340583613125 + }, + { + "step": 174, + "lr": 0.0001, + "sup_loss": 1.612851693540602 + }, + { + "step": 175, + "lr": 0.0001, + "sup_loss": 1.6110975775679166, + "lyap1_mean": -6.304257392883301, + "lyap1_max": -6.284839153289795, + "lyap_spec_mean": [ + -6.304257392883301, + -6.30750846862793 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 176, + "lr": 0.0001, + "sup_loss": 1.61914691618028 + }, + { + "step": 177, + "lr": 0.0001, + "sup_loss": 1.618533874469112 + }, + { + "step": 178, + "lr": 0.0001, + "sup_loss": 1.6225511296653723 + }, + { + "step": 179, + "lr": 0.0001, + "sup_loss": 1.6409765068011015 + }, + { + "step": 180, + "lr": 0.0001, + "sup_loss": 1.6209402621335396 + }, + { + "step": 181, + "lr": 0.0001, + "sup_loss": 1.5903578498662685 + }, + { + "step": 182, + "lr": 0.0001, + "sup_loss": 1.6243800011765677 + }, + { + "step": 183, + "lr": 0.0001, + "sup_loss": 1.6207408935168828 + }, + { + "step": 184, + "lr": 0.0001, + "sup_loss": 1.6102868840186222 + }, + { + "step": 185, + "lr": 0.0001, + "sup_loss": 1.6001848591227634 + }, + { + "step": 186, + "lr": 0.0001, + "sup_loss": 1.572493708893578 + }, + { + "step": 187, + "lr": 0.0001, + "sup_loss": 1.612159538574632 + }, + { + "step": 188, + "lr": 0.0001, + "sup_loss": 1.5911217530125168 + }, + { + "step": 189, + "lr": 0.0001, + "sup_loss": 1.6293490369187993 + }, + { + "step": 190, + "lr": 0.0001, + "sup_loss": 1.6040246983038626 + }, + { + "step": 191, + "lr": 0.0001, + "sup_loss": 1.6171197527958248 + }, + { + "step": 192, + "lr": 0.0001, + "sup_loss": 1.6471899354369277 + }, + { + "step": 193, + "lr": 0.0001, + "sup_loss": 1.6034272540262462 + }, + { + "step": 194, + "lr": 0.0001, + "sup_loss": 1.624265957837026 + }, + { + "step": 195, + "lr": 0.0001, + "sup_loss": 1.6315334681058467 + }, + { + "step": 196, + "lr": 0.0001, + "sup_loss": 1.6182992051901102 + }, + { + "step": 197, + "lr": 0.0001, + "sup_loss": 1.6026089533859447 + }, + { + "step": 198, + "lr": 0.0001, + "sup_loss": 1.6068981420107973 + }, + { + "step": 199, + "lr": 0.0001, + "sup_loss": 1.6226155394597461 + }, + { + "step": 200, + "lr": 0.0001, + "sup_loss": 1.5908226672539212, + "lyap1_mean": -6.314453125, + "lyap1_max": -6.295107841491699, + "lyap_spec_mean": [ + -6.314453601837158, + -6.311760902404785 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 201, + "lr": 0.0001, + "sup_loss": 1.614759653061085 + }, + { + "step": 202, + "lr": 0.0001, + "sup_loss": 1.607828428395806 + }, + { + "step": 203, + "lr": 0.0001, + "sup_loss": 1.6031055264743805 + }, + { + "step": 204, + "lr": 0.0001, + "sup_loss": 1.62692512809244 + }, + { + "step": 205, + "lr": 0.0001, + "sup_loss": 1.6197515599744592 + }, + { + "step": 206, + "lr": 0.0001, + "sup_loss": 1.5945279526481753 + }, + { + "step": 207, + "lr": 0.0001, + "sup_loss": 1.600027352742842 + }, + { + "step": 208, + "lr": 0.0001, + "sup_loss": 1.6231346460135334 + }, + { + "step": 209, + "lr": 0.0001, + "sup_loss": 1.6045676349961688 + }, + { + "step": 210, + "lr": 0.0001, + "sup_loss": 1.612343899125989 + }, + { + "step": 211, + "lr": 0.0001, + "sup_loss": 1.572819151638782 + }, + { + "step": 212, + "lr": 0.0001, + "sup_loss": 1.5998946197093518 + }, + { + "step": 213, + "lr": 0.0001, + "sup_loss": 1.603872718653751 + }, + { + "step": 214, + "lr": 0.0001, + "sup_loss": 1.6064486221293404 + }, + { + "step": 215, + "lr": 0.0001, + "sup_loss": 1.5816140347137049 + }, + { + "step": 216, + "lr": 0.0001, + "sup_loss": 1.623563311041461 + }, + { + "step": 217, + "lr": 0.0001, + "sup_loss": 1.604757450088786 + }, + { + "step": 218, + "lr": 0.0001, + "sup_loss": 1.5856211225488168 + }, + { + "step": 219, + "lr": 0.0001, + "sup_loss": 1.5971583490656518 + }, + { + "step": 220, + "lr": 0.0001, + "sup_loss": 1.62120464502734 + }, + { + "step": 221, + "lr": 0.0001, + "sup_loss": 1.5521333505669912 + }, + { + "step": 222, + "lr": 0.0001, + "sup_loss": 1.5910480072140367 + }, + { + "step": 223, + "lr": 0.0001, + "sup_loss": 1.5878960555935198 + }, + { + "step": 224, + "lr": 0.0001, + "sup_loss": 1.52525868655689 + }, + { + "step": 225, + "lr": 0.0001, + "sup_loss": 1.6046161077785628, + "lyap1_mean": -6.307826995849609, + "lyap1_max": -6.286316394805908, + "lyap_spec_mean": [ + -6.307826995849609, + -6.311221122741699 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 226, + "lr": 0.0001, + "sup_loss": 1.5787563174285753 + }, + { + "step": 227, + "lr": 0.0001, + "sup_loss": 1.6046591313503475 + }, + { + "step": 228, + "lr": 0.0001, + "sup_loss": 1.6058233574528387 + }, + { + "step": 229, + "lr": 0.0001, + "sup_loss": 1.5708493836588395 + }, + { + "step": 230, + "lr": 0.0001, + "sup_loss": 1.5522555239571714 + }, + { + "step": 231, + "lr": 0.0001, + "sup_loss": 1.5866450454598817 + }, + { + "step": 232, + "lr": 0.0001, + "sup_loss": 1.5833501739262028 + }, + { + "step": 233, + "lr": 0.0001, + "sup_loss": 1.5781072194587922 + }, + { + "step": 234, + "lr": 0.0001, + "sup_loss": 1.5801195205359906 + }, + { + "step": 235, + "lr": 0.0001, + "sup_loss": 1.6097866642525447 + }, + { + "step": 236, + "lr": 0.0001, + "sup_loss": 1.5776707740181835 + }, + { + "step": 237, + "lr": 0.0001, + "sup_loss": 1.575370573452357 + }, + { + "step": 238, + "lr": 0.0001, + "sup_loss": 1.62187735175436 + }, + { + "step": 239, + "lr": 0.0001, + "sup_loss": 1.5719111789223998 + }, + { + "step": 240, + "lr": 0.0001, + "sup_loss": 1.6043917104768717 + }, + { + "step": 241, + "lr": 0.0001, + "sup_loss": 1.6115212118102145 + }, + { + "step": 242, + "lr": 0.0001, + "sup_loss": 1.5726522914277772 + }, + { + "step": 243, + "lr": 0.0001, + "sup_loss": 1.5747379788820692 + }, + { + "step": 244, + "lr": 0.0001, + "sup_loss": 1.602347413668085 + }, + { + "step": 245, + "lr": 0.0001, + "sup_loss": 1.561972573460076 + }, + { + "step": 246, + "lr": 0.0001, + "sup_loss": 1.579944843245691 + }, + { + "step": 247, + "lr": 0.0001, + "sup_loss": 1.56607517962854 + }, + { + "step": 248, + "lr": 0.0001, + "sup_loss": 1.5602422723452187 + }, + { + "step": 249, + "lr": 0.0001, + "sup_loss": 1.5481532506755131 + }, + { + "step": 250, + "lr": 0.0001, + "sup_loss": 1.6282572215428823, + "lyap1_mean": -6.311943054199219, + "lyap1_max": -6.285268306732178, + "lyap_spec_mean": [ + -6.311943054199219, + -6.315288543701172 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 251, + "lr": 0.0001, + "sup_loss": 1.5718172405729163 + }, + { + "step": 252, + "lr": 0.0001, + "sup_loss": 1.568016116494461 + }, + { + "step": 253, + "lr": 0.0001, + "sup_loss": 1.5892380828003114 + }, + { + "step": 254, + "lr": 0.0001, + "sup_loss": 1.5607691734001938 + }, + { + "step": 255, + "lr": 0.0001, + "sup_loss": 1.5788166224967786 + }, + { + "step": 256, + "lr": 0.0001, + "sup_loss": 1.5587572791400528 + }, + { + "step": 257, + "lr": 0.0001, + "sup_loss": 1.56509858619077 + }, + { + "step": 258, + "lr": 0.0001, + "sup_loss": 1.5588711212966218 + }, + { + "step": 259, + "lr": 0.0001, + "sup_loss": 1.579683401292984 + }, + { + "step": 260, + "lr": 0.0001, + "sup_loss": 1.5572354648170486 + }, + { + "step": 261, + "lr": 0.0001, + "sup_loss": 1.569087077453923 + }, + { + "step": 262, + "lr": 0.0001, + "sup_loss": 1.552346801093667 + }, + { + "step": 263, + "lr": 0.0001, + "sup_loss": 1.5730190896596785 + }, + { + "step": 264, + "lr": 0.0001, + "sup_loss": 1.5592950476448364 + }, + { + "step": 265, + "lr": 0.0001, + "sup_loss": 1.578283494419273 + }, + { + "step": 266, + "lr": 0.0001, + "sup_loss": 1.5317856999633797 + }, + { + "step": 267, + "lr": 0.0001, + "sup_loss": 1.5859820808572964 + }, + { + "step": 268, + "lr": 0.0001, + "sup_loss": 1.5849993822920676 + }, + { + "step": 269, + "lr": 0.0001, + "sup_loss": 1.5748490996922742 + }, + { + "step": 270, + "lr": 0.0001, + "sup_loss": 1.5941484134857486 + }, + { + "step": 271, + "lr": 0.0001, + "sup_loss": 1.5520565621157805 + }, + { + "step": 272, + "lr": 0.0001, + "sup_loss": 1.5736600032776027 + }, + { + "step": 273, + "lr": 0.0001, + "sup_loss": 1.5703344026318378 + }, + { + "step": 274, + "lr": 0.0001, + "sup_loss": 1.532767851458178 + }, + { + "step": 275, + "lr": 0.0001, + "sup_loss": 1.5764611628543121, + "lyap1_mean": -6.288212776184082, + "lyap1_max": -6.271989822387695, + "lyap_spec_mean": [ + -6.288212776184082, + -6.290098190307617 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 276, + "lr": 0.0001, + "sup_loss": 1.5627879826848854 + }, + { + "step": 277, + "lr": 0.0001, + "sup_loss": 1.5565442095845055 + }, + { + "step": 278, + "lr": 0.0001, + "sup_loss": 1.5479018965033426 + }, + { + "step": 279, + "lr": 0.0001, + "sup_loss": 1.542800690022451 + }, + { + "step": 280, + "lr": 0.0001, + "sup_loss": 1.5708411044949124 + }, + { + "step": 281, + "lr": 0.0001, + "sup_loss": 1.5704922914677404 + }, + { + "step": 282, + "lr": 0.0001, + "sup_loss": 1.548503892204476 + }, + { + "step": 283, + "lr": 0.0001, + "sup_loss": 1.557741653174852 + }, + { + "step": 284, + "lr": 0.0001, + "sup_loss": 1.5737748118594674 + }, + { + "step": 285, + "lr": 0.0001, + "sup_loss": 1.5217131287518002 + }, + { + "step": 286, + "lr": 0.0001, + "sup_loss": 1.5508766477654388 + }, + { + "step": 287, + "lr": 0.0001, + "sup_loss": 1.5681149739226237 + }, + { + "step": 288, + "lr": 0.0001, + "sup_loss": 1.533574656235852 + }, + { + "step": 289, + "lr": 0.0001, + "sup_loss": 1.5711439676427719 + }, + { + "step": 290, + "lr": 0.0001, + "sup_loss": 1.5541693707191668 + }, + { + "step": 291, + "lr": 0.0001, + "sup_loss": 1.53935113280687 + }, + { + "step": 292, + "lr": 0.0001, + "sup_loss": 1.5477303077305633 + }, + { + "step": 293, + "lr": 0.0001, + "sup_loss": 1.5411001058204383 + }, + { + "step": 294, + "lr": 0.0001, + "sup_loss": 1.566108745714733 + }, + { + "step": 295, + "lr": 0.0001, + "sup_loss": 1.5431387629950557 + }, + { + "step": 296, + "lr": 0.0001, + "sup_loss": 1.5719911366769372 + }, + { + "step": 297, + "lr": 0.0001, + "sup_loss": 1.5459029921829308 + }, + { + "step": 298, + "lr": 0.0001, + "sup_loss": 1.5684083943193499 + }, + { + "step": 299, + "lr": 0.0001, + "sup_loss": 1.5552347272080564 + }, + { + "step": 300, + "lr": 0.0001, + "sup_loss": 1.5612322177126692, + "lyap1_mean": -6.289813995361328, + "lyap1_max": -6.263297080993652, + "lyap_spec_mean": [ + -6.289813995361328, + -6.282321453094482 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 301, + "lr": 0.0001, + "sup_loss": 1.5511914784971887 + }, + { + "step": 302, + "lr": 0.0001, + "sup_loss": 1.5731978045920958 + }, + { + "step": 303, + "lr": 0.0001, + "sup_loss": 1.5566588069651133 + }, + { + "step": 304, + "lr": 0.0001, + "sup_loss": 1.5435834816545064 + }, + { + "step": 305, + "lr": 0.0001, + "sup_loss": 1.5338201112718275 + }, + { + "step": 306, + "lr": 0.0001, + "sup_loss": 1.5620164001408299 + }, + { + "step": 307, + "lr": 0.0001, + "sup_loss": 1.5461411309298845 + }, + { + "step": 308, + "lr": 0.0001, + "sup_loss": 1.556008165963498 + }, + { + "step": 309, + "lr": 0.0001, + "sup_loss": 1.5554833750200956 + }, + { + "step": 310, + "lr": 0.0001, + "sup_loss": 1.568397089848242 + }, + { + "step": 311, + "lr": 0.0001, + "sup_loss": 1.5708716932718876 + }, + { + "step": 312, + "lr": 0.0001, + "sup_loss": 1.5195926766923842 + }, + { + "step": 313, + "lr": 0.0001, + "sup_loss": 1.52811400474664 + }, + { + "step": 314, + "lr": 0.0001, + "sup_loss": 1.5539360130593718 + }, + { + "step": 315, + "lr": 0.0001, + "sup_loss": 1.5706093056068795 + }, + { + "step": 316, + "lr": 0.0001, + "sup_loss": 1.557120468837921 + }, + { + "step": 317, + "lr": 0.0001, + "sup_loss": 1.5822501082816158 + }, + { + "step": 318, + "lr": 0.0001, + "sup_loss": 1.542841458798004 + }, + { + "step": 319, + "lr": 0.0001, + "sup_loss": 1.5563868638207532 + }, + { + "step": 320, + "lr": 0.0001, + "sup_loss": 1.5360635360486008 + }, + { + "step": 321, + "lr": 0.0001, + "sup_loss": 1.5459013446151262 + }, + { + "step": 322, + "lr": 0.0001, + "sup_loss": 1.5867201314501376 + }, + { + "step": 323, + "lr": 0.0001, + "sup_loss": 1.5681245372992967 + }, + { + "step": 324, + "lr": 0.0001, + "sup_loss": 1.545037808734181 + }, + { + "step": 325, + "lr": 0.0001, + "sup_loss": 1.5807109835114312, + "lyap1_mean": -6.280990123748779, + "lyap1_max": -6.268655776977539, + "lyap_spec_mean": [ + -6.2809906005859375, + -6.283902168273926 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 326, + "lr": 0.0001, + "sup_loss": 1.5361487778088874 + }, + { + "step": 327, + "lr": 0.0001, + "sup_loss": 1.5569850983489886 + }, + { + "step": 328, + "lr": 0.0001, + "sup_loss": 1.5468934937491015 + }, + { + "step": 329, + "lr": 0.0001, + "sup_loss": 1.5269107579149266 + }, + { + "step": 330, + "lr": 0.0001, + "sup_loss": 1.5308932888735198 + }, + { + "step": 331, + "lr": 0.0001, + "sup_loss": 1.546140456130772 + }, + { + "step": 332, + "lr": 0.0001, + "sup_loss": 1.556001616894801 + }, + { + "step": 333, + "lr": 0.0001, + "sup_loss": 1.5160081181707756 + }, + { + "step": 334, + "lr": 0.0001, + "sup_loss": 1.5370807622724176 + }, + { + "step": 335, + "lr": 0.0001, + "sup_loss": 1.5463874980357313 + }, + { + "step": 336, + "lr": 0.0001, + "sup_loss": 1.527108314657003 + }, + { + "step": 337, + "lr": 0.0001, + "sup_loss": 1.5391164403451145 + }, + { + "step": 338, + "lr": 0.0001, + "sup_loss": 1.5288020191539669 + }, + { + "step": 339, + "lr": 0.0001, + "sup_loss": 1.544628633865707 + }, + { + "step": 340, + "lr": 0.0001, + "sup_loss": 1.5508991977799556 + }, + { + "step": 341, + "lr": 0.0001, + "sup_loss": 1.55731107953372 + }, + { + "step": 342, + "lr": 0.0001, + "sup_loss": 1.5502437895717247 + }, + { + "step": 343, + "lr": 0.0001, + "sup_loss": 1.5113026766574436 + }, + { + "step": 344, + "lr": 0.0001, + "sup_loss": 1.534505224713083 + }, + { + "step": 345, + "lr": 0.0001, + "sup_loss": 1.5664212448478674 + }, + { + "step": 346, + "lr": 0.0001, + "sup_loss": 1.5343774635089513 + }, + { + "step": 347, + "lr": 0.0001, + "sup_loss": 1.523872870702963 + }, + { + "step": 348, + "lr": 0.0001, + "sup_loss": 1.520222813804984 + }, + { + "step": 349, + "lr": 0.0001, + "sup_loss": 1.5100668329858764 + }, + { + "step": 350, + "lr": 0.0001, + "sup_loss": 1.5462873210196821, + "lyap1_mean": -6.279208660125732, + "lyap1_max": -6.246695518493652, + "lyap_spec_mean": [ + -6.279209136962891, + -6.2811126708984375 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 351, + "lr": 0.0001, + "sup_loss": 1.5592996002285948 + }, + { + "step": 352, + "lr": 0.0001, + "sup_loss": 1.513165697344076 + }, + { + "step": 353, + "lr": 0.0001, + "sup_loss": 1.5556921340697518 + }, + { + "step": 354, + "lr": 0.0001, + "sup_loss": 1.558373381312493 + }, + { + "step": 355, + "lr": 0.0001, + "sup_loss": 1.5547521752157896 + }, + { + "step": 356, + "lr": 0.0001, + "sup_loss": 1.5482859037251404 + }, + { + "step": 357, + "lr": 0.0001, + "sup_loss": 1.5541198311222053 + }, + { + "step": 358, + "lr": 0.0001, + "sup_loss": 1.513929981198374 + }, + { + "step": 359, + "lr": 0.0001, + "sup_loss": 1.5386774539004036 + }, + { + "step": 360, + "lr": 0.0001, + "sup_loss": 1.5418122629340056 + }, + { + "step": 361, + "lr": 0.0001, + "sup_loss": 1.5336020776983843 + }, + { + "step": 362, + "lr": 0.0001, + "sup_loss": 1.5442231828959216 + }, + { + "step": 363, + "lr": 0.0001, + "sup_loss": 1.5474763280659718 + }, + { + "step": 364, + "lr": 0.0001, + "sup_loss": 1.5401739408673039 + }, + { + "step": 365, + "lr": 0.0001, + "sup_loss": 1.5340803578606583 + }, + { + "step": 366, + "lr": 0.0001, + "sup_loss": 1.5137462377878363 + }, + { + "step": 367, + "lr": 0.0001, + "sup_loss": 1.5490127083318859 + }, + { + "step": 368, + "lr": 0.0001, + "sup_loss": 1.562103831097833 + }, + { + "step": 369, + "lr": 0.0001, + "sup_loss": 1.5230020136679903 + }, + { + "step": 370, + "lr": 0.0001, + "sup_loss": 1.519926874355663 + }, + { + "step": 371, + "lr": 0.0001, + "sup_loss": 1.525188796570022 + }, + { + "step": 372, + "lr": 0.0001, + "sup_loss": 1.5389628270751545 + }, + { + "step": 373, + "lr": 0.0001, + "sup_loss": 1.5206521555610368 + }, + { + "step": 374, + "lr": 0.0001, + "sup_loss": 1.5910327063155232 + }, + { + "step": 375, + "lr": 0.0001, + "sup_loss": 1.5517228598442367, + "lyap1_mean": -6.272121906280518, + "lyap1_max": -6.257327079772949, + "lyap_spec_mean": [ + -6.272121906280518, + -6.272157669067383 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 376, + "lr": 0.0001, + "sup_loss": 1.5083365432341427 + }, + { + "step": 377, + "lr": 0.0001, + "sup_loss": 1.5351844511019792 + }, + { + "step": 378, + "lr": 0.0001, + "sup_loss": 1.5185103477122763 + }, + { + "step": 379, + "lr": 0.0001, + "sup_loss": 1.5313015037319202 + }, + { + "step": 380, + "lr": 0.0001, + "sup_loss": 1.6042587657443281 + }, + { + "step": 381, + "lr": 0.0001, + "sup_loss": 1.5148778440809103 + }, + { + "step": 382, + "lr": 0.0001, + "sup_loss": 1.547646792356559 + }, + { + "step": 383, + "lr": 0.0001, + "sup_loss": 1.5043766820879998 + }, + { + "step": 384, + "lr": 0.0001, + "sup_loss": 1.517374048269513 + }, + { + "step": 385, + "lr": 0.0001, + "sup_loss": 1.510813145580335 + }, + { + "step": 386, + "lr": 0.0001, + "sup_loss": 1.5343651897756998 + }, + { + "step": 387, + "lr": 0.0001, + "sup_loss": 1.5567518054948828 + }, + { + "step": 388, + "lr": 0.0001, + "sup_loss": 1.556583401528102 + }, + { + "step": 389, + "lr": 0.0001, + "sup_loss": 1.5469114160109558 + }, + { + "step": 390, + "lr": 0.0001, + "sup_loss": 1.5066436477329854 + }, + { + "step": 391, + "lr": 0.0001, + "sup_loss": 1.5363803613218583 + }, + { + "step": 392, + "lr": 0.0001, + "sup_loss": 1.5623538263511423 + }, + { + "step": 393, + "lr": 0.0001, + "sup_loss": 1.5509992112423387 + }, + { + "step": 394, + "lr": 0.0001, + "sup_loss": 1.5553260421123227 + }, + { + "step": 395, + "lr": 0.0001, + "sup_loss": 1.5360717974523455 + }, + { + "step": 396, + "lr": 0.0001, + "sup_loss": 1.5299607690174781 + }, + { + "step": 397, + "lr": 0.0001, + "sup_loss": 1.4931204366796695 + }, + { + "step": 398, + "lr": 0.0001, + "sup_loss": 1.5352384127840748 + }, + { + "step": 399, + "lr": 0.0001, + "sup_loss": 1.5222885300656976 + }, + { + "step": 400, + "lr": 0.0001, + "sup_loss": 1.508831153333313, + "lyap1_mean": -6.27598237991333, + "lyap1_max": -6.24452018737793, + "lyap_spec_mean": [ + -6.275981903076172, + -6.269106388092041 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 401, + "lr": 0.0001, + "sup_loss": 1.5349017639824347 + }, + { + "step": 402, + "lr": 0.0001, + "sup_loss": 1.548015367001545 + }, + { + "step": 403, + "lr": 0.0001, + "sup_loss": 1.5078454672949264 + }, + { + "step": 404, + "lr": 0.0001, + "sup_loss": 1.5185558897396196 + }, + { + "step": 405, + "lr": 0.0001, + "sup_loss": 1.5512310382424748 + }, + { + "step": 406, + "lr": 0.0001, + "sup_loss": 1.5304067426341317 + }, + { + "step": 407, + "lr": 0.0001, + "sup_loss": 1.5183398062918037 + }, + { + "step": 408, + "lr": 0.0001, + "sup_loss": 1.5387815991781382 + }, + { + "step": 409, + "lr": 0.0001, + "sup_loss": 1.5672918045341844 + }, + { + "step": 410, + "lr": 0.0001, + "sup_loss": 1.5307374295242138 + }, + { + "step": 411, + "lr": 0.0001, + "sup_loss": 1.544239649750348 + }, + { + "step": 412, + "lr": 0.0001, + "sup_loss": 1.5372248394722121 + }, + { + "step": 413, + "lr": 0.0001, + "sup_loss": 1.546755674066759 + }, + { + "step": 414, + "lr": 0.0001, + "sup_loss": 1.5602227617649562 + }, + { + "step": 415, + "lr": 0.0001, + "sup_loss": 1.5235959308536382 + }, + { + "step": 416, + "lr": 0.0001, + "sup_loss": 1.54999620670243 + }, + { + "step": 417, + "lr": 0.0001, + "sup_loss": 1.5595363483742926 + }, + { + "step": 418, + "lr": 0.0001, + "sup_loss": 1.5429251013869647 + }, + { + "step": 419, + "lr": 0.0001, + "sup_loss": 1.5263398785761602 + }, + { + "step": 420, + "lr": 0.0001, + "sup_loss": 1.5403264813934174 + }, + { + "step": 421, + "lr": 0.0001, + "sup_loss": 1.51891197855286 + }, + { + "step": 422, + "lr": 0.0001, + "sup_loss": 1.5330320818314984 + }, + { + "step": 423, + "lr": 0.0001, + "sup_loss": 1.5024285323810576 + }, + { + "step": 424, + "lr": 0.0001, + "sup_loss": 1.5529554719113352 + }, + { + "step": 425, + "lr": 0.0001, + "sup_loss": 1.519168167373818, + "lyap1_mean": -6.279496192932129, + "lyap1_max": -6.26162052154541, + "lyap_spec_mean": [ + -6.279496192932129, + -6.2808918952941895 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 426, + "lr": 0.0001, + "sup_loss": 1.5365064575118708 + }, + { + "step": 427, + "lr": 0.0001, + "sup_loss": 1.5222562257747192 + }, + { + "step": 428, + "lr": 0.0001, + "sup_loss": 1.519125449620276 + }, + { + "step": 429, + "lr": 0.0001, + "sup_loss": 1.529261269354274 + }, + { + "step": 430, + "lr": 0.0001, + "sup_loss": 1.52106984620442 + }, + { + "step": 431, + "lr": 0.0001, + "sup_loss": 1.542332523616496 + }, + { + "step": 432, + "lr": 0.0001, + "sup_loss": 1.5053887182166101 + }, + { + "step": 433, + "lr": 0.0001, + "sup_loss": 1.5287912390123242 + }, + { + "step": 434, + "lr": 0.0001, + "sup_loss": 1.4792699148804047 + }, + { + "step": 435, + "lr": 0.0001, + "sup_loss": 1.5175428625480079 + }, + { + "step": 436, + "lr": 0.0001, + "sup_loss": 1.5141915348633057 + }, + { + "step": 437, + "lr": 0.0001, + "sup_loss": 1.5021534012618962 + }, + { + "step": 438, + "lr": 0.0001, + "sup_loss": 1.515655711068608 + }, + { + "step": 439, + "lr": 0.0001, + "sup_loss": 1.5336998941946303 + }, + { + "step": 440, + "lr": 0.0001, + "sup_loss": 1.5709049462152431 + }, + { + "step": 441, + "lr": 0.0001, + "sup_loss": 1.5345619270812774 + }, + { + "step": 442, + "lr": 0.0001, + "sup_loss": 1.545632307238727 + }, + { + "step": 443, + "lr": 0.0001, + "sup_loss": 1.5348385538551335 + }, + { + "step": 444, + "lr": 0.0001, + "sup_loss": 1.5596831114341054 + }, + { + "step": 445, + "lr": 0.0001, + "sup_loss": 1.5213286739984129 + }, + { + "step": 446, + "lr": 0.0001, + "sup_loss": 1.507136513986345 + }, + { + "step": 447, + "lr": 0.0001, + "sup_loss": 1.5338240960099745 + }, + { + "step": 448, + "lr": 0.0001, + "sup_loss": 1.5335693962074035 + }, + { + "step": 449, + "lr": 0.0001, + "sup_loss": 1.5439888653044145 + }, + { + "step": 450, + "lr": 0.0001, + "sup_loss": 1.527999408648118, + "lyap1_mean": -6.28324031829834, + "lyap1_max": -6.266049385070801, + "lyap_spec_mean": [ + -6.28324031829834, + -6.283727169036865 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 451, + "lr": 0.0001, + "sup_loss": 1.5393156317969563 + }, + { + "step": 452, + "lr": 0.0001, + "sup_loss": 1.5240758554208984 + }, + { + "step": 453, + "lr": 0.0001, + "sup_loss": 1.5172760077652057 + }, + { + "step": 454, + "lr": 0.0001, + "sup_loss": 1.5435138079852262 + }, + { + "step": 455, + "lr": 0.0001, + "sup_loss": 1.553782064658805 + }, + { + "step": 456, + "lr": 0.0001, + "sup_loss": 1.4990875570761242 + }, + { + "step": 457, + "lr": 0.0001, + "sup_loss": 1.526767795262043 + }, + { + "step": 458, + "lr": 0.0001, + "sup_loss": 1.5074100872415515 + }, + { + "step": 459, + "lr": 0.0001, + "sup_loss": 1.5299431484804877 + }, + { + "step": 460, + "lr": 0.0001, + "sup_loss": 1.5411429028548818 + }, + { + "step": 461, + "lr": 0.0001, + "sup_loss": 1.5258069753257875 + }, + { + "step": 462, + "lr": 0.0001, + "sup_loss": 1.5130222736269014 + }, + { + "step": 463, + "lr": 0.0001, + "sup_loss": 1.59688740678216 + }, + { + "step": 464, + "lr": 0.0001, + "sup_loss": 1.5169865077256424 + }, + { + "step": 465, + "lr": 0.0001, + "sup_loss": 1.522381168712973 + }, + { + "step": 466, + "lr": 0.0001, + "sup_loss": 1.522439002600057 + }, + { + "step": 467, + "lr": 0.0001, + "sup_loss": 1.5190416825884472 + }, + { + "step": 468, + "lr": 0.0001, + "sup_loss": 1.5425338998993232 + }, + { + "step": 469, + "lr": 0.0001, + "sup_loss": 1.5452529428590425 + }, + { + "step": 470, + "lr": 0.0001, + "sup_loss": 1.5260539108805669 + }, + { + "step": 471, + "lr": 0.0001, + "sup_loss": 1.5488179073420898 + }, + { + "step": 472, + "lr": 0.0001, + "sup_loss": 1.5192884004268512 + }, + { + "step": 473, + "lr": 0.0001, + "sup_loss": 1.5055062362761682 + }, + { + "step": 474, + "lr": 0.0001, + "sup_loss": 1.4984221563948537 + }, + { + "step": 475, + "lr": 0.0001, + "sup_loss": 1.5320479692645415, + "lyap1_mean": -6.27734375, + "lyap1_max": -6.261284828186035, + "lyap_spec_mean": [ + -6.277344226837158, + -6.2793049812316895 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 476, + "lr": 0.0001, + "sup_loss": 1.538385270074266 + }, + { + "step": 477, + "lr": 0.0001, + "sup_loss": 1.4984740868654256 + }, + { + "step": 478, + "lr": 0.0001, + "sup_loss": 1.5450349077570704 + }, + { + "step": 479, + "lr": 0.0001, + "sup_loss": 1.5320467747126512 + }, + { + "step": 480, + "lr": 0.0001, + "sup_loss": 1.5451753778273984 + }, + { + "step": 481, + "lr": 0.0001, + "sup_loss": 1.5345277338401393 + }, + { + "step": 482, + "lr": 0.0001, + "sup_loss": 1.5576481611049358 + }, + { + "step": 483, + "lr": 0.0001, + "sup_loss": 1.525092799737688 + }, + { + "step": 484, + "lr": 0.0001, + "sup_loss": 1.5177981040203947 + }, + { + "step": 485, + "lr": 0.0001, + "sup_loss": 1.524682836990655 + }, + { + "step": 486, + "lr": 0.0001, + "sup_loss": 1.5577210090147655 + }, + { + "step": 487, + "lr": 0.0001, + "sup_loss": 1.5175527588503717 + }, + { + "step": 488, + "lr": 0.0001, + "sup_loss": 1.517884672177967 + }, + { + "step": 489, + "lr": 0.0001, + "sup_loss": 1.540989397132943 + }, + { + "step": 490, + "lr": 0.0001, + "sup_loss": 1.5207840823262242 + }, + { + "step": 491, + "lr": 0.0001, + "sup_loss": 1.5308205979089273 + }, + { + "step": 492, + "lr": 0.0001, + "sup_loss": 1.5343529235115525 + }, + { + "step": 493, + "lr": 0.0001, + "sup_loss": 1.4972792643274797 + }, + { + "step": 494, + "lr": 0.0001, + "sup_loss": 1.5436764958011016 + }, + { + "step": 495, + "lr": 0.0001, + "sup_loss": 1.5344808545549244 + }, + { + "step": 496, + "lr": 0.0001, + "sup_loss": 1.5101506555087487 + }, + { + "step": 497, + "lr": 0.0001, + "sup_loss": 1.5398357969125787 + }, + { + "step": 498, + "lr": 0.0001, + "sup_loss": 1.5341583392864167 + }, + { + "step": 499, + "lr": 0.0001, + "sup_loss": 1.5103523937991166 + } + ], + "evals": [ + { + "step": 0, + "acc": 0.0, + "tok_acc": 0.0 + }, + { + "step": 100, + "acc": 0.0, + "tok_acc": 0.38816550925925924 + }, + { + "step": 200, + "acc": 0.0, + "tok_acc": 0.3872974537037037 + }, + { + "step": 300, + "acc": 0.0, + "tok_acc": 0.3872974537037037 + }, + { + "step": 400, + "acc": 0.0, + "tok_acc": 0.39052854938271603 + }, + { + "step": 500, + "acc": 0.0, + "tok_acc": 0.3880208333333333 + } + ], + "final_acc": 0.0, + "final_tok_acc": 0.3880208333333333 +}
\ No newline at end of file diff --git a/srm/runs/srm_v1_7M_sudoku1k_3k.json b/srm/runs/srm_v1_7M_sudoku1k_3k.json new file mode 100644 index 0000000..0afadcc --- /dev/null +++ b/srm/runs/srm_v1_7M_sudoku1k_3k.json @@ -0,0 +1,15517 @@ +{ + "args": { + "data_path": "/home/yurenh2/rrm/data/sudoku-extreme-1k-aug-1000", + "n_steps": 3000, + "batch_size": 8, + "lr": 0.0001, + "puzzle_emb_lr": 0.0001, + "warmup_steps": 200, + "weight_decay": 1.0, + "hidden_size": 512, + "n_iters": 12, + "n_aol_layers": 5, + "kappa": 0.9, + "eta": 1.0, + "alpha": 1.0, + "k_lyap": 2, + "lyap_iters": 8, + "lyap_every": 50, + "seed": 42, + "eval_every": 300, + "eval_n": 512, + "eval_batch_size": 32, + "out": "runs/srm_v1_7M_sudoku1k_3k.json", + "save_ckpt": "ckpts/srm_v1_7M_3k.pt" + }, + "n_params": 6869236, + "initial_acc": 0.0, + "initial_tok_acc": 0.11072530864197531, + "initial_lip": { + "lip_emp_mean": 4.566142308704002e-08, + "lip_emp_max": 5.301484407027601e-08, + "lip_emp_99p": 5.179779805075668e-08, + "lip_theoretical_bound": 0.9, + "passes_bound": true + }, + "steps": [ + { + "step": 0, + "lr": 0.0, + "sup_loss": 2.545388497314158, + "lyap1_mean": -16.591732025146484, + "lyap1_max": -16.564510345458984, + "lyap_spec_mean": [ + -16.591732025146484, + -16.587482452392578 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1, + "lr": 5e-07, + "sup_loss": 2.520062125852257 + }, + { + "step": 2, + "lr": 1e-06, + "sup_loss": 2.5401019492153294 + }, + { + "step": 3, + "lr": 1.5e-06, + "sup_loss": 2.541414888335374 + }, + { + "step": 4, + "lr": 2e-06, + "sup_loss": 2.5445404259304185 + }, + { + "step": 5, + "lr": 2.5e-06, + "sup_loss": 2.544604022147916 + }, + { + "step": 6, + "lr": 3e-06, + "sup_loss": 2.5139777369216754 + }, + { + "step": 7, + "lr": 3.5e-06, + "sup_loss": 2.53090131215773 + }, + { + "step": 8, + "lr": 4e-06, + "sup_loss": 2.5181077778125167 + }, + { + "step": 9, + "lr": 4.5e-06, + "sup_loss": 2.5336223439798546 + }, + { + "step": 10, + "lr": 5e-06, + "sup_loss": 2.5004438372921713 + }, + { + "step": 11, + "lr": 5.500000000000001e-06, + "sup_loss": 2.500397831436203 + }, + { + "step": 12, + "lr": 6e-06, + "sup_loss": 2.514644659350256 + }, + { + "step": 13, + "lr": 6.5000000000000004e-06, + "sup_loss": 2.5053497221639836 + }, + { + "step": 14, + "lr": 7e-06, + "sup_loss": 2.4932143679006065 + }, + { + "step": 15, + "lr": 7.5e-06, + "sup_loss": 2.5039324402283887 + }, + { + "step": 16, + "lr": 8e-06, + "sup_loss": 2.4999695373334183 + }, + { + "step": 17, + "lr": 8.5e-06, + "sup_loss": 2.4715084261110647 + }, + { + "step": 18, + "lr": 9e-06, + "sup_loss": 2.4646305943266644 + }, + { + "step": 19, + "lr": 9.5e-06, + "sup_loss": 2.4279348480117995 + }, + { + "step": 20, + "lr": 1e-05, + "sup_loss": 2.4388607308610775 + }, + { + "step": 21, + "lr": 1.0500000000000001e-05, + "sup_loss": 2.4238828014090403 + }, + { + "step": 22, + "lr": 1.1000000000000001e-05, + "sup_loss": 2.4337139840790405 + }, + { + "step": 23, + "lr": 1.15e-05, + "sup_loss": 2.4281116385182964 + }, + { + "step": 24, + "lr": 1.2e-05, + "sup_loss": 2.39559567554181 + }, + { + "step": 25, + "lr": 1.25e-05, + "sup_loss": 2.3949485266753854 + }, + { + "step": 26, + "lr": 1.3000000000000001e-05, + "sup_loss": 2.358922499176413 + }, + { + "step": 27, + "lr": 1.3500000000000001e-05, + "sup_loss": 2.3565614093149567 + }, + { + "step": 28, + "lr": 1.4e-05, + "sup_loss": 2.383434605726758 + }, + { + "step": 29, + "lr": 1.4500000000000002e-05, + "sup_loss": 2.3896169688655604 + }, + { + "step": 30, + "lr": 1.5e-05, + "sup_loss": 2.338761299908307 + }, + { + "step": 31, + "lr": 1.55e-05, + "sup_loss": 2.3102453996857837 + }, + { + "step": 32, + "lr": 1.6e-05, + "sup_loss": 2.322905824594401 + }, + { + "step": 33, + "lr": 1.65e-05, + "sup_loss": 2.315363400514065 + }, + { + "step": 34, + "lr": 1.7e-05, + "sup_loss": 2.277430686700119 + }, + { + "step": 35, + "lr": 1.7500000000000002e-05, + "sup_loss": 2.285889955223168 + }, + { + "step": 36, + "lr": 1.8e-05, + "sup_loss": 2.273734133118314 + }, + { + "step": 37, + "lr": 1.8500000000000002e-05, + "sup_loss": 2.2575386614327755 + }, + { + "step": 38, + "lr": 1.9e-05, + "sup_loss": 2.2411266077943717 + }, + { + "step": 39, + "lr": 1.95e-05, + "sup_loss": 2.2475000956812576 + }, + { + "step": 40, + "lr": 2e-05, + "sup_loss": 2.2180165447401876 + }, + { + "step": 41, + "lr": 2.05e-05, + "sup_loss": 2.2254883297794104 + }, + { + "step": 42, + "lr": 2.1000000000000002e-05, + "sup_loss": 2.2245932501231276 + }, + { + "step": 43, + "lr": 2.15e-05, + "sup_loss": 2.1796953983390916 + }, + { + "step": 44, + "lr": 2.2000000000000003e-05, + "sup_loss": 2.2089661213882943 + }, + { + "step": 45, + "lr": 2.25e-05, + "sup_loss": 2.1688508683222447 + }, + { + "step": 46, + "lr": 2.3e-05, + "sup_loss": 2.172612517816952 + }, + { + "step": 47, + "lr": 2.3500000000000002e-05, + "sup_loss": 2.1523102979723996 + }, + { + "step": 48, + "lr": 2.4e-05, + "sup_loss": 2.1498654952498053 + }, + { + "step": 49, + "lr": 2.45e-05, + "sup_loss": 2.1472931735713097 + }, + { + "step": 50, + "lr": 2.5e-05, + "sup_loss": 2.143014239028663, + "lyap1_mean": -16.918052673339844, + "lyap1_max": -16.8529109954834, + "lyap_spec_mean": [ + -16.918052673339844, + -16.922578811645508 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 51, + "lr": 2.5500000000000003e-05, + "sup_loss": 2.1366468357293793 + }, + { + "step": 52, + "lr": 2.6000000000000002e-05, + "sup_loss": 2.0814824435696417 + }, + { + "step": 53, + "lr": 2.65e-05, + "sup_loss": 2.0904627840078445 + }, + { + "step": 54, + "lr": 2.7000000000000002e-05, + "sup_loss": 2.0856293491144773 + }, + { + "step": 55, + "lr": 2.7500000000000004e-05, + "sup_loss": 2.0905153299963217 + }, + { + "step": 56, + "lr": 2.8e-05, + "sup_loss": 2.0874446462353586 + }, + { + "step": 57, + "lr": 2.85e-05, + "sup_loss": 2.0731640567223266 + }, + { + "step": 58, + "lr": 2.9000000000000004e-05, + "sup_loss": 2.068913765747051 + }, + { + "step": 59, + "lr": 2.95e-05, + "sup_loss": 2.0321220050099456 + }, + { + "step": 60, + "lr": 3e-05, + "sup_loss": 2.039560733981708 + }, + { + "step": 61, + "lr": 3.0500000000000003e-05, + "sup_loss": 2.0311050393582954 + }, + { + "step": 62, + "lr": 3.1e-05, + "sup_loss": 2.023536867022937 + }, + { + "step": 63, + "lr": 3.15e-05, + "sup_loss": 2.012712282327772 + }, + { + "step": 64, + "lr": 3.2e-05, + "sup_loss": 1.9895662289668616 + }, + { + "step": 65, + "lr": 3.2500000000000004e-05, + "sup_loss": 2.00573949675443 + }, + { + "step": 66, + "lr": 3.3e-05, + "sup_loss": 1.9787640293857178 + }, + { + "step": 67, + "lr": 3.35e-05, + "sup_loss": 1.972293977513286 + }, + { + "step": 68, + "lr": 3.4e-05, + "sup_loss": 1.9723419950107408 + }, + { + "step": 69, + "lr": 3.4500000000000005e-05, + "sup_loss": 1.9654930336422252 + }, + { + "step": 70, + "lr": 3.5000000000000004e-05, + "sup_loss": 1.960238565605203 + }, + { + "step": 71, + "lr": 3.55e-05, + "sup_loss": 1.946865884454777 + }, + { + "step": 72, + "lr": 3.6e-05, + "sup_loss": 1.9353493570877125 + }, + { + "step": 73, + "lr": 3.65e-05, + "sup_loss": 1.9190507243093153 + }, + { + "step": 74, + "lr": 3.7000000000000005e-05, + "sup_loss": 1.9216891112755936 + }, + { + "step": 75, + "lr": 3.7500000000000003e-05, + "sup_loss": 1.928104376862006 + }, + { + "step": 76, + "lr": 3.8e-05, + "sup_loss": 1.908872015314727 + }, + { + "step": 77, + "lr": 3.85e-05, + "sup_loss": 1.9038224428383652 + }, + { + "step": 78, + "lr": 3.9e-05, + "sup_loss": 1.908470684287983 + }, + { + "step": 79, + "lr": 3.9500000000000005e-05, + "sup_loss": 1.9006691564433424 + }, + { + "step": 80, + "lr": 4e-05, + "sup_loss": 1.8743926803907092 + }, + { + "step": 81, + "lr": 4.0499999999999995e-05, + "sup_loss": 1.8752125309344267 + }, + { + "step": 82, + "lr": 4.1e-05, + "sup_loss": 1.8476202373453925 + }, + { + "step": 83, + "lr": 4.15e-05, + "sup_loss": 1.8625218866493753 + }, + { + "step": 84, + "lr": 4.2000000000000004e-05, + "sup_loss": 1.8558469714931147 + }, + { + "step": 85, + "lr": 4.25e-05, + "sup_loss": 1.8378518003501194 + }, + { + "step": 86, + "lr": 4.3e-05, + "sup_loss": 1.8299320035381321 + }, + { + "step": 87, + "lr": 4.350000000000001e-05, + "sup_loss": 1.8286555014986339 + }, + { + "step": 88, + "lr": 4.4000000000000006e-05, + "sup_loss": 1.8463436871915169 + }, + { + "step": 89, + "lr": 4.45e-05, + "sup_loss": 1.8248907248495 + }, + { + "step": 90, + "lr": 4.5e-05, + "sup_loss": 1.8091619336800226 + }, + { + "step": 91, + "lr": 4.55e-05, + "sup_loss": 1.8116371199886308 + }, + { + "step": 92, + "lr": 4.6e-05, + "sup_loss": 1.8024278161917549 + }, + { + "step": 93, + "lr": 4.6500000000000005e-05, + "sup_loss": 1.7857707078309426 + }, + { + "step": 94, + "lr": 4.7000000000000004e-05, + "sup_loss": 1.8015773186789588 + }, + { + "step": 95, + "lr": 4.7499999999999996e-05, + "sup_loss": 1.7815456372285252 + }, + { + "step": 96, + "lr": 4.8e-05, + "sup_loss": 1.7857859334682855 + }, + { + "step": 97, + "lr": 4.85e-05, + "sup_loss": 1.7814948727940696 + }, + { + "step": 98, + "lr": 4.9e-05, + "sup_loss": 1.7859203612205619 + }, + { + "step": 99, + "lr": 4.9500000000000004e-05, + "sup_loss": 1.7633073071482288 + }, + { + "step": 100, + "lr": 5e-05, + "sup_loss": 1.749137886640539, + "lyap1_mean": -16.546123504638672, + "lyap1_max": -16.499147415161133, + "lyap_spec_mean": [ + -16.546125411987305, + -16.557605743408203 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 101, + "lr": 5.050000000000001e-05, + "sup_loss": 1.7516780029297327 + }, + { + "step": 102, + "lr": 5.1000000000000006e-05, + "sup_loss": 1.7542192928392524 + }, + { + "step": 103, + "lr": 5.15e-05, + "sup_loss": 1.758186825576543 + }, + { + "step": 104, + "lr": 5.2000000000000004e-05, + "sup_loss": 1.740310638467503 + }, + { + "step": 105, + "lr": 5.25e-05, + "sup_loss": 1.7340111500177182 + }, + { + "step": 106, + "lr": 5.3e-05, + "sup_loss": 1.7329404153254435 + }, + { + "step": 107, + "lr": 5.3500000000000006e-05, + "sup_loss": 1.7275449830293221 + }, + { + "step": 108, + "lr": 5.4000000000000005e-05, + "sup_loss": 1.7262494352938373 + }, + { + "step": 109, + "lr": 5.4499999999999997e-05, + "sup_loss": 1.7024765444598133 + }, + { + "step": 110, + "lr": 5.500000000000001e-05, + "sup_loss": 1.7120000258009922 + }, + { + "step": 111, + "lr": 5.55e-05, + "sup_loss": 1.7031516089183187 + }, + { + "step": 112, + "lr": 5.6e-05, + "sup_loss": 1.728018202909447 + }, + { + "step": 113, + "lr": 5.6500000000000005e-05, + "sup_loss": 1.7091894804721155 + }, + { + "step": 114, + "lr": 5.7e-05, + "sup_loss": 1.7043584749679423 + }, + { + "step": 115, + "lr": 5.75e-05, + "sup_loss": 1.6568847494341825 + }, + { + "step": 116, + "lr": 5.800000000000001e-05, + "sup_loss": 1.6805926019007698 + }, + { + "step": 117, + "lr": 5.85e-05, + "sup_loss": 1.703872008245952 + }, + { + "step": 118, + "lr": 5.9e-05, + "sup_loss": 1.6823422522353808 + }, + { + "step": 119, + "lr": 5.95e-05, + "sup_loss": 1.6595561845360967 + }, + { + "step": 120, + "lr": 6e-05, + "sup_loss": 1.6681964209101177 + }, + { + "step": 121, + "lr": 6.050000000000001e-05, + "sup_loss": 1.6812294999431794 + }, + { + "step": 122, + "lr": 6.1000000000000005e-05, + "sup_loss": 1.6876474415755067 + }, + { + "step": 123, + "lr": 6.15e-05, + "sup_loss": 1.684829344928463 + }, + { + "step": 124, + "lr": 6.2e-05, + "sup_loss": 1.6832337149213155 + }, + { + "step": 125, + "lr": 6.25e-05, + "sup_loss": 1.6768433395838978 + }, + { + "step": 126, + "lr": 6.3e-05, + "sup_loss": 1.6563331318961014 + }, + { + "step": 127, + "lr": 6.350000000000001e-05, + "sup_loss": 1.6422538462032277 + }, + { + "step": 128, + "lr": 6.4e-05, + "sup_loss": 1.650632587007114 + }, + { + "step": 129, + "lr": 6.45e-05, + "sup_loss": 1.636353762380422 + }, + { + "step": 130, + "lr": 6.500000000000001e-05, + "sup_loss": 1.6214526462060446 + }, + { + "step": 131, + "lr": 6.55e-05, + "sup_loss": 1.6460770688290096 + }, + { + "step": 132, + "lr": 6.6e-05, + "sup_loss": 1.6370297239242264 + }, + { + "step": 133, + "lr": 6.65e-05, + "sup_loss": 1.6686424525772805 + }, + { + "step": 134, + "lr": 6.7e-05, + "sup_loss": 1.644915211472824 + }, + { + "step": 135, + "lr": 6.75e-05, + "sup_loss": 1.6595162434349684 + }, + { + "step": 136, + "lr": 6.8e-05, + "sup_loss": 1.674740805749333 + }, + { + "step": 137, + "lr": 6.85e-05, + "sup_loss": 1.6544656217632967 + }, + { + "step": 138, + "lr": 6.900000000000001e-05, + "sup_loss": 1.649680463638582 + }, + { + "step": 139, + "lr": 6.950000000000001e-05, + "sup_loss": 1.628350327902047 + }, + { + "step": 140, + "lr": 7.000000000000001e-05, + "sup_loss": 1.6499040061125425 + }, + { + "step": 141, + "lr": 7.05e-05, + "sup_loss": 1.6783952801695923 + }, + { + "step": 142, + "lr": 7.1e-05, + "sup_loss": 1.6312781619134684 + }, + { + "step": 143, + "lr": 7.15e-05, + "sup_loss": 1.6151848402388453 + }, + { + "step": 144, + "lr": 7.2e-05, + "sup_loss": 1.666482538368257 + }, + { + "step": 145, + "lr": 7.25e-05, + "sup_loss": 1.6147687382154745 + }, + { + "step": 146, + "lr": 7.3e-05, + "sup_loss": 1.6423219755220124 + }, + { + "step": 147, + "lr": 7.350000000000001e-05, + "sup_loss": 1.6349052848464927 + }, + { + "step": 148, + "lr": 7.400000000000001e-05, + "sup_loss": 1.564486616501131 + }, + { + "step": 149, + "lr": 7.45e-05, + "sup_loss": 1.5952894429569016 + }, + { + "step": 150, + "lr": 7.500000000000001e-05, + "sup_loss": 1.6072027271163234, + "lyap1_mean": -15.320697784423828, + "lyap1_max": -15.170461654663086, + "lyap_spec_mean": [ + -15.320697784423828, + -15.36007308959961 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 151, + "lr": 7.55e-05, + "sup_loss": 1.629904038121481 + }, + { + "step": 152, + "lr": 7.6e-05, + "sup_loss": 1.6154697798857927 + }, + { + "step": 153, + "lr": 7.65e-05, + "sup_loss": 1.5897304250934883 + }, + { + "step": 154, + "lr": 7.7e-05, + "sup_loss": 1.6312396536927336 + }, + { + "step": 155, + "lr": 7.75e-05, + "sup_loss": 1.6204636841281057 + }, + { + "step": 156, + "lr": 7.8e-05, + "sup_loss": 1.6310431467852267 + }, + { + "step": 157, + "lr": 7.850000000000001e-05, + "sup_loss": 1.5991707993194202 + }, + { + "step": 158, + "lr": 7.900000000000001e-05, + "sup_loss": 1.6001230265663404 + }, + { + "step": 159, + "lr": 7.950000000000001e-05, + "sup_loss": 1.63382038208027 + }, + { + "step": 160, + "lr": 8e-05, + "sup_loss": 1.6234039701610425 + }, + { + "step": 161, + "lr": 8.05e-05, + "sup_loss": 1.5541464551724393 + }, + { + "step": 162, + "lr": 8.099999999999999e-05, + "sup_loss": 1.595696984441022 + }, + { + "step": 163, + "lr": 8.150000000000002e-05, + "sup_loss": 1.6004328154862009 + }, + { + "step": 164, + "lr": 8.2e-05, + "sup_loss": 1.5649726023722013 + }, + { + "step": 165, + "lr": 8.25e-05, + "sup_loss": 1.5895463019882323 + }, + { + "step": 166, + "lr": 8.3e-05, + "sup_loss": 1.5947065120508046 + }, + { + "step": 167, + "lr": 8.35e-05, + "sup_loss": 1.5678144384391373 + }, + { + "step": 168, + "lr": 8.400000000000001e-05, + "sup_loss": 1.61713849068063 + }, + { + "step": 169, + "lr": 8.450000000000001e-05, + "sup_loss": 1.5715750485377458 + }, + { + "step": 170, + "lr": 8.5e-05, + "sup_loss": 1.5898771453200746 + }, + { + "step": 171, + "lr": 8.55e-05, + "sup_loss": 1.5884602095578788 + }, + { + "step": 172, + "lr": 8.6e-05, + "sup_loss": 1.5870489294841537 + }, + { + "step": 173, + "lr": 8.65e-05, + "sup_loss": 1.5698268652324014 + }, + { + "step": 174, + "lr": 8.700000000000001e-05, + "sup_loss": 1.5633158451601286 + }, + { + "step": 175, + "lr": 8.750000000000001e-05, + "sup_loss": 1.562199086162526 + }, + { + "step": 176, + "lr": 8.800000000000001e-05, + "sup_loss": 1.5696177528603659 + }, + { + "step": 177, + "lr": 8.85e-05, + "sup_loss": 1.5700466905267636 + }, + { + "step": 178, + "lr": 8.9e-05, + "sup_loss": 1.5748911545928015 + }, + { + "step": 179, + "lr": 8.95e-05, + "sup_loss": 1.594718319599315 + }, + { + "step": 180, + "lr": 9e-05, + "sup_loss": 1.5729019246994131 + }, + { + "step": 181, + "lr": 9.05e-05, + "sup_loss": 1.5403525919372176 + }, + { + "step": 182, + "lr": 9.1e-05, + "sup_loss": 1.5778584864331255 + }, + { + "step": 183, + "lr": 9.15e-05, + "sup_loss": 1.5735868229766863 + }, + { + "step": 184, + "lr": 9.2e-05, + "sup_loss": 1.5616653359831962 + }, + { + "step": 185, + "lr": 9.250000000000001e-05, + "sup_loss": 1.5503534458189467 + }, + { + "step": 186, + "lr": 9.300000000000001e-05, + "sup_loss": 1.5230171047090646 + }, + { + "step": 187, + "lr": 9.350000000000001e-05, + "sup_loss": 1.5659364015331518 + }, + { + "step": 188, + "lr": 9.400000000000001e-05, + "sup_loss": 1.5428544288052446 + }, + { + "step": 189, + "lr": 9.45e-05, + "sup_loss": 1.5841358113755202 + }, + { + "step": 190, + "lr": 9.499999999999999e-05, + "sup_loss": 1.5570893348201698 + }, + { + "step": 191, + "lr": 9.550000000000002e-05, + "sup_loss": 1.5721590053339976 + }, + { + "step": 192, + "lr": 9.6e-05, + "sup_loss": 1.6046612562995117 + }, + { + "step": 193, + "lr": 9.65e-05, + "sup_loss": 1.557942953451703 + }, + { + "step": 194, + "lr": 9.7e-05, + "sup_loss": 1.5794450168460041 + }, + { + "step": 195, + "lr": 9.75e-05, + "sup_loss": 1.5879573812306729 + }, + { + "step": 196, + "lr": 9.8e-05, + "sup_loss": 1.5741866974540388 + }, + { + "step": 197, + "lr": 9.850000000000001e-05, + "sup_loss": 1.5578307132398128 + }, + { + "step": 198, + "lr": 9.900000000000001e-05, + "sup_loss": 1.5626090988619514 + }, + { + "step": 199, + "lr": 9.95e-05, + "sup_loss": 1.5784330617895097 + }, + { + "step": 200, + "lr": 0.0001, + "sup_loss": 1.546401136135047, + "lyap1_mean": -13.368176460266113, + "lyap1_max": -13.05943489074707, + "lyap_spec_mean": [ + -13.36817741394043, + -13.445384979248047 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 201, + "lr": 0.0001, + "sup_loss": 1.5707265626098772 + }, + { + "step": 202, + "lr": 0.0001, + "sup_loss": 1.5629171279387688 + }, + { + "step": 203, + "lr": 0.0001, + "sup_loss": 1.5591698327696404 + }, + { + "step": 204, + "lr": 0.0001, + "sup_loss": 1.585064422243319 + }, + { + "step": 205, + "lr": 0.0001, + "sup_loss": 1.5770335808605092 + }, + { + "step": 206, + "lr": 0.0001, + "sup_loss": 1.5506618331915807 + }, + { + "step": 207, + "lr": 0.0001, + "sup_loss": 1.5566892124718412 + }, + { + "step": 208, + "lr": 0.0001, + "sup_loss": 1.5817056119087138 + }, + { + "step": 209, + "lr": 0.0001, + "sup_loss": 1.5620699338112491 + }, + { + "step": 210, + "lr": 0.0001, + "sup_loss": 1.5702948694656993 + }, + { + "step": 211, + "lr": 0.0001, + "sup_loss": 1.5285576594611012 + }, + { + "step": 212, + "lr": 0.0001, + "sup_loss": 1.557410632062521 + }, + { + "step": 213, + "lr": 0.0001, + "sup_loss": 1.5618627398768223 + }, + { + "step": 214, + "lr": 0.0001, + "sup_loss": 1.5652052144883482 + }, + { + "step": 215, + "lr": 0.0001, + "sup_loss": 1.5398064408676364 + }, + { + "step": 216, + "lr": 0.0001, + "sup_loss": 1.583365873349433 + }, + { + "step": 217, + "lr": 0.0001, + "sup_loss": 1.5647626402196404 + }, + { + "step": 218, + "lr": 0.0001, + "sup_loss": 1.5450069693157535 + }, + { + "step": 219, + "lr": 0.0001, + "sup_loss": 1.5570499121593666 + }, + { + "step": 220, + "lr": 0.0001, + "sup_loss": 1.5830725200500773 + }, + { + "step": 221, + "lr": 0.0001, + "sup_loss": 1.5093789472282069 + }, + { + "step": 222, + "lr": 0.0001, + "sup_loss": 1.5510206021558364 + }, + { + "step": 223, + "lr": 0.0001, + "sup_loss": 1.5473453186468795 + }, + { + "step": 224, + "lr": 0.0001, + "sup_loss": 1.4829352037843218 + }, + { + "step": 225, + "lr": 0.0001, + "sup_loss": 1.5657744773879758 + }, + { + "step": 226, + "lr": 0.0001, + "sup_loss": 1.5393384417931062 + }, + { + "step": 227, + "lr": 0.0001, + "sup_loss": 1.5678270349115604 + }, + { + "step": 228, + "lr": 0.0001, + "sup_loss": 1.5685422572235481 + }, + { + "step": 229, + "lr": 0.0001, + "sup_loss": 1.531041954977997 + }, + { + "step": 230, + "lr": 0.0001, + "sup_loss": 1.5138149851172324 + }, + { + "step": 231, + "lr": 0.0001, + "sup_loss": 1.54822918470603 + }, + { + "step": 232, + "lr": 0.0001, + "sup_loss": 1.5431681817167595 + }, + { + "step": 233, + "lr": 0.0001, + "sup_loss": 1.539734213338812 + }, + { + "step": 234, + "lr": 0.0001, + "sup_loss": 1.5416799692784875 + }, + { + "step": 235, + "lr": 0.0001, + "sup_loss": 1.5745525285420325 + }, + { + "step": 236, + "lr": 0.0001, + "sup_loss": 1.5421012001162497 + }, + { + "step": 237, + "lr": 0.0001, + "sup_loss": 1.538678641555442 + }, + { + "step": 238, + "lr": 0.0001, + "sup_loss": 1.5874294234526345 + }, + { + "step": 239, + "lr": 0.0001, + "sup_loss": 1.5342173889444943 + }, + { + "step": 240, + "lr": 0.0001, + "sup_loss": 1.570358153924424 + }, + { + "step": 241, + "lr": 0.0001, + "sup_loss": 1.577295845726841 + }, + { + "step": 242, + "lr": 0.0001, + "sup_loss": 1.5362609267440928 + }, + { + "step": 243, + "lr": 0.0001, + "sup_loss": 1.5400144670632003 + }, + { + "step": 244, + "lr": 0.0001, + "sup_loss": 1.567541306328402 + }, + { + "step": 245, + "lr": 0.0001, + "sup_loss": 1.524807518343752 + }, + { + "step": 246, + "lr": 0.0001, + "sup_loss": 1.5447458102219007 + }, + { + "step": 247, + "lr": 0.0001, + "sup_loss": 1.5317127849537944 + }, + { + "step": 248, + "lr": 0.0001, + "sup_loss": 1.5242111286932032 + }, + { + "step": 249, + "lr": 0.0001, + "sup_loss": 1.5115628344971517 + }, + { + "step": 250, + "lr": 0.0001, + "sup_loss": 1.5968853980420181, + "lyap1_mean": -12.76065444946289, + "lyap1_max": -12.461627960205078, + "lyap_spec_mean": [ + -12.760655403137207, + -13.074414253234863 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 251, + "lr": 0.0001, + "sup_loss": 1.5377164252426143 + }, + { + "step": 252, + "lr": 0.0001, + "sup_loss": 1.533783487987029 + }, + { + "step": 253, + "lr": 0.0001, + "sup_loss": 1.5559082000631896 + }, + { + "step": 254, + "lr": 0.0001, + "sup_loss": 1.5265757917998573 + }, + { + "step": 255, + "lr": 0.0001, + "sup_loss": 1.5457447492958314 + }, + { + "step": 256, + "lr": 0.0001, + "sup_loss": 1.5245200520636855 + }, + { + "step": 257, + "lr": 0.0001, + "sup_loss": 1.5321827173336249 + }, + { + "step": 258, + "lr": 0.0001, + "sup_loss": 1.5253010675095062 + }, + { + "step": 259, + "lr": 0.0001, + "sup_loss": 1.5475077878105938 + }, + { + "step": 260, + "lr": 0.0001, + "sup_loss": 1.5240957494835288 + }, + { + "step": 261, + "lr": 0.0001, + "sup_loss": 1.53623332007266 + }, + { + "step": 262, + "lr": 0.0001, + "sup_loss": 1.5202508931036083 + }, + { + "step": 263, + "lr": 0.0001, + "sup_loss": 1.5409615128856442 + }, + { + "step": 264, + "lr": 0.0001, + "sup_loss": 1.5257998029523558 + }, + { + "step": 265, + "lr": 0.0001, + "sup_loss": 1.5476147485705918 + }, + { + "step": 266, + "lr": 0.0001, + "sup_loss": 1.4998600979850383 + }, + { + "step": 267, + "lr": 0.0001, + "sup_loss": 1.5563129452518811 + }, + { + "step": 268, + "lr": 0.0001, + "sup_loss": 1.55459653794199 + }, + { + "step": 269, + "lr": 0.0001, + "sup_loss": 1.5446183629575183 + }, + { + "step": 270, + "lr": 0.0001, + "sup_loss": 1.5649884375054481 + }, + { + "step": 271, + "lr": 0.0001, + "sup_loss": 1.5211582730400968 + }, + { + "step": 272, + "lr": 0.0001, + "sup_loss": 1.543548698685395 + }, + { + "step": 273, + "lr": 0.0001, + "sup_loss": 1.5403129099767445 + }, + { + "step": 274, + "lr": 0.0001, + "sup_loss": 1.502185424947168 + }, + { + "step": 275, + "lr": 0.0001, + "sup_loss": 1.5470820699206331 + }, + { + "step": 276, + "lr": 0.0001, + "sup_loss": 1.5331444350093189 + }, + { + "step": 277, + "lr": 0.0001, + "sup_loss": 1.526654793416104 + }, + { + "step": 278, + "lr": 0.0001, + "sup_loss": 1.5178877199071896 + }, + { + "step": 279, + "lr": 0.0001, + "sup_loss": 1.5130648259466557 + }, + { + "step": 280, + "lr": 0.0001, + "sup_loss": 1.5428109867825983 + }, + { + "step": 281, + "lr": 0.0001, + "sup_loss": 1.5413153901102445 + }, + { + "step": 282, + "lr": 0.0001, + "sup_loss": 1.5190851763243107 + }, + { + "step": 283, + "lr": 0.0001, + "sup_loss": 1.5294673094150493 + }, + { + "step": 284, + "lr": 0.0001, + "sup_loss": 1.5473096360150873 + }, + { + "step": 285, + "lr": 0.0001, + "sup_loss": 1.4936461705105055 + }, + { + "step": 286, + "lr": 0.0001, + "sup_loss": 1.5249270753168769 + }, + { + "step": 287, + "lr": 0.0001, + "sup_loss": 1.5409716495584647 + }, + { + "step": 288, + "lr": 0.0001, + "sup_loss": 1.5067128654123965 + }, + { + "step": 289, + "lr": 0.0001, + "sup_loss": 1.5453923666837237 + }, + { + "step": 290, + "lr": 0.0001, + "sup_loss": 1.5279357854214093 + }, + { + "step": 291, + "lr": 0.0001, + "sup_loss": 1.5108843102545828 + }, + { + "step": 292, + "lr": 0.0001, + "sup_loss": 1.5207642683045743 + }, + { + "step": 293, + "lr": 0.0001, + "sup_loss": 1.5144269104225796 + }, + { + "step": 294, + "lr": 0.0001, + "sup_loss": 1.540427461953779 + }, + { + "step": 295, + "lr": 0.0001, + "sup_loss": 1.51775692418918 + }, + { + "step": 296, + "lr": 0.0001, + "sup_loss": 1.5466497962445158 + }, + { + "step": 297, + "lr": 0.0001, + "sup_loss": 1.5208219815455593 + }, + { + "step": 298, + "lr": 0.0001, + "sup_loss": 1.5438470075505335 + }, + { + "step": 299, + "lr": 0.0001, + "sup_loss": 1.5295875607777705 + }, + { + "step": 300, + "lr": 0.0001, + "sup_loss": 1.5363952104257168, + "lyap1_mean": -12.055841445922852, + "lyap1_max": -11.794698715209961, + "lyap_spec_mean": [ + -12.055841445922852, + -12.482438087463379 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 301, + "lr": 0.0001, + "sup_loss": 1.5265253785013224 + }, + { + "step": 302, + "lr": 0.0001, + "sup_loss": 1.5485932805615643 + }, + { + "step": 303, + "lr": 0.0001, + "sup_loss": 1.532059308595103 + }, + { + "step": 304, + "lr": 0.0001, + "sup_loss": 1.5185844766050065 + }, + { + "step": 305, + "lr": 0.0001, + "sup_loss": 1.5085965441514197 + }, + { + "step": 306, + "lr": 0.0001, + "sup_loss": 1.5381650129617592 + }, + { + "step": 307, + "lr": 0.0001, + "sup_loss": 1.5217289345523757 + }, + { + "step": 308, + "lr": 0.0001, + "sup_loss": 1.5314473551414873 + }, + { + "step": 309, + "lr": 0.0001, + "sup_loss": 1.5318292820057853 + }, + { + "step": 310, + "lr": 0.0001, + "sup_loss": 1.5454147006924128 + }, + { + "step": 311, + "lr": 0.0001, + "sup_loss": 1.5478995522167183 + }, + { + "step": 312, + "lr": 0.0001, + "sup_loss": 1.4948824485879793 + }, + { + "step": 313, + "lr": 0.0001, + "sup_loss": 1.5039715192494232 + }, + { + "step": 314, + "lr": 0.0001, + "sup_loss": 1.5310677554556276 + }, + { + "step": 315, + "lr": 0.0001, + "sup_loss": 1.548645158714049 + }, + { + "step": 316, + "lr": 0.0001, + "sup_loss": 1.5351186035085373 + }, + { + "step": 317, + "lr": 0.0001, + "sup_loss": 1.5608684248986613 + }, + { + "step": 318, + "lr": 0.0001, + "sup_loss": 1.5209470817015247 + }, + { + "step": 319, + "lr": 0.0001, + "sup_loss": 1.5350719744774592 + }, + { + "step": 320, + "lr": 0.0001, + "sup_loss": 1.513667166303545 + }, + { + "step": 321, + "lr": 0.0001, + "sup_loss": 1.524381616818733 + }, + { + "step": 322, + "lr": 0.0001, + "sup_loss": 1.5661981845789286 + }, + { + "step": 323, + "lr": 0.0001, + "sup_loss": 1.5466343282902035 + }, + { + "step": 324, + "lr": 0.0001, + "sup_loss": 1.5240239027753155 + }, + { + "step": 325, + "lr": 0.0001, + "sup_loss": 1.5610773357906593 + }, + { + "step": 326, + "lr": 0.0001, + "sup_loss": 1.514108863941202 + }, + { + "step": 327, + "lr": 0.0001, + "sup_loss": 1.535609906964776 + }, + { + "step": 328, + "lr": 0.0001, + "sup_loss": 1.5251050233357124 + }, + { + "step": 329, + "lr": 0.0001, + "sup_loss": 1.5059333961857875 + }, + { + "step": 330, + "lr": 0.0001, + "sup_loss": 1.5105862635379703 + }, + { + "step": 331, + "lr": 0.0001, + "sup_loss": 1.525230871206802 + }, + { + "step": 332, + "lr": 0.0001, + "sup_loss": 1.5370990801302722 + }, + { + "step": 333, + "lr": 0.0001, + "sup_loss": 1.4955896804642668 + }, + { + "step": 334, + "lr": 0.0001, + "sup_loss": 1.517139975098678 + }, + { + "step": 335, + "lr": 0.0001, + "sup_loss": 1.5275138130473764 + }, + { + "step": 336, + "lr": 0.0001, + "sup_loss": 1.5066966942485063 + }, + { + "step": 337, + "lr": 0.0001, + "sup_loss": 1.5188494949981362 + }, + { + "step": 338, + "lr": 0.0001, + "sup_loss": 1.5081528104603086 + }, + { + "step": 339, + "lr": 0.0001, + "sup_loss": 1.5255729925551231 + }, + { + "step": 340, + "lr": 0.0001, + "sup_loss": 1.5316505299963326 + }, + { + "step": 341, + "lr": 0.0001, + "sup_loss": 1.5387272257675237 + }, + { + "step": 342, + "lr": 0.0001, + "sup_loss": 1.5316030399791563 + }, + { + "step": 343, + "lr": 0.0001, + "sup_loss": 1.4925228769503045 + }, + { + "step": 344, + "lr": 0.0001, + "sup_loss": 1.5148584998605232 + }, + { + "step": 345, + "lr": 0.0001, + "sup_loss": 1.5474290929074288 + }, + { + "step": 346, + "lr": 0.0001, + "sup_loss": 1.5152496393182984 + }, + { + "step": 347, + "lr": 0.0001, + "sup_loss": 1.5049235099664908 + }, + { + "step": 348, + "lr": 0.0001, + "sup_loss": 1.5012060507265905 + }, + { + "step": 349, + "lr": 0.0001, + "sup_loss": 1.490658940575209 + }, + { + "step": 350, + "lr": 0.0001, + "sup_loss": 1.528470635842274, + "lyap1_mean": -11.76162338256836, + "lyap1_max": -11.400915145874023, + "lyap_spec_mean": [ + -11.76162338256836, + -12.196332931518555 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 351, + "lr": 0.0001, + "sup_loss": 1.5413601384267321 + }, + { + "step": 352, + "lr": 0.0001, + "sup_loss": 1.4935529521035986 + }, + { + "step": 353, + "lr": 0.0001, + "sup_loss": 1.5377374380473017 + }, + { + "step": 354, + "lr": 0.0001, + "sup_loss": 1.540691730091662 + }, + { + "step": 355, + "lr": 0.0001, + "sup_loss": 1.5367175737465135 + }, + { + "step": 356, + "lr": 0.0001, + "sup_loss": 1.530635214732752 + }, + { + "step": 357, + "lr": 0.0001, + "sup_loss": 1.537838228473468 + }, + { + "step": 358, + "lr": 0.0001, + "sup_loss": 1.4962873036338886 + }, + { + "step": 359, + "lr": 0.0001, + "sup_loss": 1.5220921063807007 + }, + { + "step": 360, + "lr": 0.0001, + "sup_loss": 1.525491152953901 + }, + { + "step": 361, + "lr": 0.0001, + "sup_loss": 1.5163713474119085 + }, + { + "step": 362, + "lr": 0.0001, + "sup_loss": 1.527241535635908 + }, + { + "step": 363, + "lr": 0.0001, + "sup_loss": 1.5304982541321084 + }, + { + "step": 364, + "lr": 0.0001, + "sup_loss": 1.5231485266143923 + }, + { + "step": 365, + "lr": 0.0001, + "sup_loss": 1.5163112168975914 + }, + { + "step": 366, + "lr": 0.0001, + "sup_loss": 1.4956481701407742 + }, + { + "step": 367, + "lr": 0.0001, + "sup_loss": 1.5342452722976463 + }, + { + "step": 368, + "lr": 0.0001, + "sup_loss": 1.5466697642910805 + }, + { + "step": 369, + "lr": 0.0001, + "sup_loss": 1.508705077013109 + }, + { + "step": 370, + "lr": 0.0001, + "sup_loss": 1.5034609399833936 + }, + { + "step": 371, + "lr": 0.0001, + "sup_loss": 1.508052557532037 + }, + { + "step": 372, + "lr": 0.0001, + "sup_loss": 1.5233476730240343 + }, + { + "step": 373, + "lr": 0.0001, + "sup_loss": 1.5052934492967045 + }, + { + "step": 374, + "lr": 0.0001, + "sup_loss": 1.5759504070077464 + }, + { + "step": 375, + "lr": 0.0001, + "sup_loss": 1.535682558088765 + }, + { + "step": 376, + "lr": 0.0001, + "sup_loss": 1.4920791284608579 + }, + { + "step": 377, + "lr": 0.0001, + "sup_loss": 1.5194316339005662 + }, + { + "step": 378, + "lr": 0.0001, + "sup_loss": 1.5024805432250534 + }, + { + "step": 379, + "lr": 0.0001, + "sup_loss": 1.5147784185584083 + }, + { + "step": 380, + "lr": 0.0001, + "sup_loss": 1.589798218222819 + }, + { + "step": 381, + "lr": 0.0001, + "sup_loss": 1.4997049580475368 + }, + { + "step": 382, + "lr": 0.0001, + "sup_loss": 1.5326192082464976 + }, + { + "step": 383, + "lr": 0.0001, + "sup_loss": 1.4888976871603288 + }, + { + "step": 384, + "lr": 0.0001, + "sup_loss": 1.5015775235829594 + }, + { + "step": 385, + "lr": 0.0001, + "sup_loss": 1.4955910323385655 + }, + { + "step": 386, + "lr": 0.0001, + "sup_loss": 1.5194761939754748 + }, + { + "step": 387, + "lr": 0.0001, + "sup_loss": 1.5426483974957237 + }, + { + "step": 388, + "lr": 0.0001, + "sup_loss": 1.5427200981086682 + }, + { + "step": 389, + "lr": 0.0001, + "sup_loss": 1.532118576573357 + }, + { + "step": 390, + "lr": 0.0001, + "sup_loss": 1.491665999160759 + }, + { + "step": 391, + "lr": 0.0001, + "sup_loss": 1.521773124701603 + }, + { + "step": 392, + "lr": 0.0001, + "sup_loss": 1.5478305731232695 + }, + { + "step": 393, + "lr": 0.0001, + "sup_loss": 1.5358499212948626 + }, + { + "step": 394, + "lr": 0.0001, + "sup_loss": 1.5412414751324863 + }, + { + "step": 395, + "lr": 0.0001, + "sup_loss": 1.5203899037143354 + }, + { + "step": 396, + "lr": 0.0001, + "sup_loss": 1.515919086520783 + }, + { + "step": 397, + "lr": 0.0001, + "sup_loss": 1.4778075738777505 + }, + { + "step": 398, + "lr": 0.0001, + "sup_loss": 1.5215626293569535 + }, + { + "step": 399, + "lr": 0.0001, + "sup_loss": 1.50784120327608 + }, + { + "step": 400, + "lr": 0.0001, + "sup_loss": 1.4957776179249296, + "lyap1_mean": -11.334436416625977, + "lyap1_max": -11.105228424072266, + "lyap_spec_mean": [ + -11.334436416625977, + -11.996769905090332 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 401, + "lr": 0.0001, + "sup_loss": 1.5216224765463873 + }, + { + "step": 402, + "lr": 0.0001, + "sup_loss": 1.5359090141151275 + }, + { + "step": 403, + "lr": 0.0001, + "sup_loss": 1.493550738533156 + }, + { + "step": 404, + "lr": 0.0001, + "sup_loss": 1.5041753699210472 + }, + { + "step": 405, + "lr": 0.0001, + "sup_loss": 1.5382870899791226 + }, + { + "step": 406, + "lr": 0.0001, + "sup_loss": 1.516634532380017 + }, + { + "step": 407, + "lr": 0.0001, + "sup_loss": 1.5042274152492738 + }, + { + "step": 408, + "lr": 0.0001, + "sup_loss": 1.5250359873912454 + }, + { + "step": 409, + "lr": 0.0001, + "sup_loss": 1.554047747398289 + }, + { + "step": 410, + "lr": 0.0001, + "sup_loss": 1.517932638824385 + }, + { + "step": 411, + "lr": 0.0001, + "sup_loss": 1.5308098472842881 + }, + { + "step": 412, + "lr": 0.0001, + "sup_loss": 1.523420909820821 + }, + { + "step": 413, + "lr": 0.0001, + "sup_loss": 1.5347458495683204 + }, + { + "step": 414, + "lr": 0.0001, + "sup_loss": 1.5482415076628526 + }, + { + "step": 415, + "lr": 0.0001, + "sup_loss": 1.5107501599955004 + }, + { + "step": 416, + "lr": 0.0001, + "sup_loss": 1.537757427110563 + }, + { + "step": 417, + "lr": 0.0001, + "sup_loss": 1.5469087856028731 + }, + { + "step": 418, + "lr": 0.0001, + "sup_loss": 1.5306598704879266 + }, + { + "step": 419, + "lr": 0.0001, + "sup_loss": 1.5138171178660402 + }, + { + "step": 420, + "lr": 0.0001, + "sup_loss": 1.527656047414869 + }, + { + "step": 421, + "lr": 0.0001, + "sup_loss": 1.506449975387827 + }, + { + "step": 422, + "lr": 0.0001, + "sup_loss": 1.5208335392766716 + }, + { + "step": 423, + "lr": 0.0001, + "sup_loss": 1.4902017388354212 + }, + { + "step": 424, + "lr": 0.0001, + "sup_loss": 1.5413524803077843 + }, + { + "step": 425, + "lr": 0.0001, + "sup_loss": 1.5068810687235097 + }, + { + "step": 426, + "lr": 0.0001, + "sup_loss": 1.5240164442619506 + }, + { + "step": 427, + "lr": 0.0001, + "sup_loss": 1.5096646446972923 + }, + { + "step": 428, + "lr": 0.0001, + "sup_loss": 1.506460142172738 + }, + { + "step": 429, + "lr": 0.0001, + "sup_loss": 1.5166393380900016 + }, + { + "step": 430, + "lr": 0.0001, + "sup_loss": 1.5093387145577521 + }, + { + "step": 431, + "lr": 0.0001, + "sup_loss": 1.530778531504104 + }, + { + "step": 432, + "lr": 0.0001, + "sup_loss": 1.4939584475722183 + }, + { + "step": 433, + "lr": 0.0001, + "sup_loss": 1.5171645769708706 + }, + { + "step": 434, + "lr": 0.0001, + "sup_loss": 1.4664217319449346 + }, + { + "step": 435, + "lr": 0.0001, + "sup_loss": 1.5052247536880472 + }, + { + "step": 436, + "lr": 0.0001, + "sup_loss": 1.5029870995156003 + }, + { + "step": 437, + "lr": 0.0001, + "sup_loss": 1.4905454737043538 + }, + { + "step": 438, + "lr": 0.0001, + "sup_loss": 1.5033068338247517 + }, + { + "step": 439, + "lr": 0.0001, + "sup_loss": 1.5225436570716893 + }, + { + "step": 440, + "lr": 0.0001, + "sup_loss": 1.5597090054310672 + }, + { + "step": 441, + "lr": 0.0001, + "sup_loss": 1.5234853636246892 + }, + { + "step": 442, + "lr": 0.0001, + "sup_loss": 1.534649946966083 + }, + { + "step": 443, + "lr": 0.0001, + "sup_loss": 1.5228690456636231 + }, + { + "step": 444, + "lr": 0.0001, + "sup_loss": 1.549154324361503 + }, + { + "step": 445, + "lr": 0.0001, + "sup_loss": 1.5092149712440277 + }, + { + "step": 446, + "lr": 0.0001, + "sup_loss": 1.4959582278232122 + }, + { + "step": 447, + "lr": 0.0001, + "sup_loss": 1.5225026543462026 + }, + { + "step": 448, + "lr": 0.0001, + "sup_loss": 1.5220281431462264 + }, + { + "step": 449, + "lr": 0.0001, + "sup_loss": 1.5331610736299486 + }, + { + "step": 450, + "lr": 0.0001, + "sup_loss": 1.516008084891901, + "lyap1_mean": -10.886491775512695, + "lyap1_max": -10.71495246887207, + "lyap_spec_mean": [ + -10.886490821838379, + -11.48372745513916 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 451, + "lr": 0.0001, + "sup_loss": 1.5281486274054963 + }, + { + "step": 452, + "lr": 0.0001, + "sup_loss": 1.5132981839908974 + }, + { + "step": 453, + "lr": 0.0001, + "sup_loss": 1.506020706473522 + }, + { + "step": 454, + "lr": 0.0001, + "sup_loss": 1.5328268896248918 + }, + { + "step": 455, + "lr": 0.0001, + "sup_loss": 1.543571779811295 + }, + { + "step": 456, + "lr": 0.0001, + "sup_loss": 1.4875618513698212 + }, + { + "step": 457, + "lr": 0.0001, + "sup_loss": 1.5160344765585312 + }, + { + "step": 458, + "lr": 0.0001, + "sup_loss": 1.496706834535162 + }, + { + "step": 459, + "lr": 0.0001, + "sup_loss": 1.519816226362514 + }, + { + "step": 460, + "lr": 0.0001, + "sup_loss": 1.5302154606491456 + }, + { + "step": 461, + "lr": 0.0001, + "sup_loss": 1.515054851533421 + }, + { + "step": 462, + "lr": 0.0001, + "sup_loss": 1.5024020787822998 + }, + { + "step": 463, + "lr": 0.0001, + "sup_loss": 1.5868635471314814 + }, + { + "step": 464, + "lr": 0.0001, + "sup_loss": 1.5058209495205541 + }, + { + "step": 465, + "lr": 0.0001, + "sup_loss": 1.5123266278268024 + }, + { + "step": 466, + "lr": 0.0001, + "sup_loss": 1.5120566798623127 + }, + { + "step": 467, + "lr": 0.0001, + "sup_loss": 1.5090979126598907 + }, + { + "step": 468, + "lr": 0.0001, + "sup_loss": 1.5323289552471024 + }, + { + "step": 469, + "lr": 0.0001, + "sup_loss": 1.535519944862544 + }, + { + "step": 470, + "lr": 0.0001, + "sup_loss": 1.5158198348280305 + }, + { + "step": 471, + "lr": 0.0001, + "sup_loss": 1.5390713771279845 + }, + { + "step": 472, + "lr": 0.0001, + "sup_loss": 1.5099266110083536 + }, + { + "step": 473, + "lr": 0.0001, + "sup_loss": 1.4952983417388592 + }, + { + "step": 474, + "lr": 0.0001, + "sup_loss": 1.4881551282476981 + }, + { + "step": 475, + "lr": 0.0001, + "sup_loss": 1.5221923769527377 + }, + { + "step": 476, + "lr": 0.0001, + "sup_loss": 1.5288284945732573 + }, + { + "step": 477, + "lr": 0.0001, + "sup_loss": 1.4879322124914443 + }, + { + "step": 478, + "lr": 0.0001, + "sup_loss": 1.5350925664508945 + }, + { + "step": 479, + "lr": 0.0001, + "sup_loss": 1.5221501561091164 + }, + { + "step": 480, + "lr": 0.0001, + "sup_loss": 1.5348382403169307 + }, + { + "step": 481, + "lr": 0.0001, + "sup_loss": 1.5252797831776708 + }, + { + "step": 482, + "lr": 0.0001, + "sup_loss": 1.548010835870001 + }, + { + "step": 483, + "lr": 0.0001, + "sup_loss": 1.5154684962674378 + }, + { + "step": 484, + "lr": 0.0001, + "sup_loss": 1.5080549653919657 + }, + { + "step": 485, + "lr": 0.0001, + "sup_loss": 1.5154279761200906 + }, + { + "step": 486, + "lr": 0.0001, + "sup_loss": 1.5488460945883464 + }, + { + "step": 487, + "lr": 0.0001, + "sup_loss": 1.5079447739509535 + }, + { + "step": 488, + "lr": 0.0001, + "sup_loss": 1.5082584003533808 + }, + { + "step": 489, + "lr": 0.0001, + "sup_loss": 1.5317233193991164 + }, + { + "step": 490, + "lr": 0.0001, + "sup_loss": 1.5109312885090949 + }, + { + "step": 491, + "lr": 0.0001, + "sup_loss": 1.5218243009728538 + }, + { + "step": 492, + "lr": 0.0001, + "sup_loss": 1.5249214454908997 + }, + { + "step": 493, + "lr": 0.0001, + "sup_loss": 1.4878704606760282 + }, + { + "step": 494, + "lr": 0.0001, + "sup_loss": 1.5344827320892875 + }, + { + "step": 495, + "lr": 0.0001, + "sup_loss": 1.5260210121503275 + }, + { + "step": 496, + "lr": 0.0001, + "sup_loss": 1.500631589079166 + }, + { + "step": 497, + "lr": 0.0001, + "sup_loss": 1.5306146853932743 + }, + { + "step": 498, + "lr": 0.0001, + "sup_loss": 1.5256995954508872 + }, + { + "step": 499, + "lr": 0.0001, + "sup_loss": 1.5015291124305707 + }, + { + "step": 500, + "lr": 0.0001, + "sup_loss": 1.518727935741119, + "lyap1_mean": -10.704227447509766, + "lyap1_max": -10.380502700805664, + "lyap_spec_mean": [ + -10.704227447509766, + -11.454790115356445 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 501, + "lr": 0.0001, + "sup_loss": 1.5420552040354285 + }, + { + "step": 502, + "lr": 0.0001, + "sup_loss": 1.5420224015274795 + }, + { + "step": 503, + "lr": 0.0001, + "sup_loss": 1.535579572824871 + }, + { + "step": 504, + "lr": 0.0001, + "sup_loss": 1.5307738799223558 + }, + { + "step": 505, + "lr": 0.0001, + "sup_loss": 1.5114492257411185 + }, + { + "step": 506, + "lr": 0.0001, + "sup_loss": 1.5322547497396821 + }, + { + "step": 507, + "lr": 0.0001, + "sup_loss": 1.5012640372746309 + }, + { + "step": 508, + "lr": 0.0001, + "sup_loss": 1.515905728106991 + }, + { + "step": 509, + "lr": 0.0001, + "sup_loss": 1.5076106365856818 + }, + { + "step": 510, + "lr": 0.0001, + "sup_loss": 1.4472614738253793 + }, + { + "step": 511, + "lr": 0.0001, + "sup_loss": 1.5251136855330647 + }, + { + "step": 512, + "lr": 0.0001, + "sup_loss": 1.5357037800845472 + }, + { + "step": 513, + "lr": 0.0001, + "sup_loss": 1.514495507139802 + }, + { + "step": 514, + "lr": 0.0001, + "sup_loss": 1.5492908231682714 + }, + { + "step": 515, + "lr": 0.0001, + "sup_loss": 1.4961621376987646 + }, + { + "step": 516, + "lr": 0.0001, + "sup_loss": 1.498826844054637 + }, + { + "step": 517, + "lr": 0.0001, + "sup_loss": 1.4979865871056692 + }, + { + "step": 518, + "lr": 0.0001, + "sup_loss": 1.5373061606385496 + }, + { + "step": 519, + "lr": 0.0001, + "sup_loss": 1.481182795657155 + }, + { + "step": 520, + "lr": 0.0001, + "sup_loss": 1.477984591324481 + }, + { + "step": 521, + "lr": 0.0001, + "sup_loss": 1.5452183030970241 + }, + { + "step": 522, + "lr": 0.0001, + "sup_loss": 1.5073475343843927 + }, + { + "step": 523, + "lr": 0.0001, + "sup_loss": 1.5270415359708072 + }, + { + "step": 524, + "lr": 0.0001, + "sup_loss": 1.535959679520951 + }, + { + "step": 525, + "lr": 0.0001, + "sup_loss": 1.5168191562792326 + }, + { + "step": 526, + "lr": 0.0001, + "sup_loss": 1.4874999947601295 + }, + { + "step": 527, + "lr": 0.0001, + "sup_loss": 1.477051435023021 + }, + { + "step": 528, + "lr": 0.0001, + "sup_loss": 1.4397327822724786 + }, + { + "step": 529, + "lr": 0.0001, + "sup_loss": 1.4616725742989656 + }, + { + "step": 530, + "lr": 0.0001, + "sup_loss": 1.503122216674289 + }, + { + "step": 531, + "lr": 0.0001, + "sup_loss": 1.5234685717426049 + }, + { + "step": 532, + "lr": 0.0001, + "sup_loss": 1.524883964174737 + }, + { + "step": 533, + "lr": 0.0001, + "sup_loss": 1.4800176732111547 + }, + { + "step": 534, + "lr": 0.0001, + "sup_loss": 1.532849136702353 + }, + { + "step": 535, + "lr": 0.0001, + "sup_loss": 1.5179139255477903 + }, + { + "step": 536, + "lr": 0.0001, + "sup_loss": 1.5213231049434022 + }, + { + "step": 537, + "lr": 0.0001, + "sup_loss": 1.5274944131365837 + }, + { + "step": 538, + "lr": 0.0001, + "sup_loss": 1.5005829312670993 + }, + { + "step": 539, + "lr": 0.0001, + "sup_loss": 1.5211662363087692 + }, + { + "step": 540, + "lr": 0.0001, + "sup_loss": 1.538015863914101 + }, + { + "step": 541, + "lr": 0.0001, + "sup_loss": 1.538406369767912 + }, + { + "step": 542, + "lr": 0.0001, + "sup_loss": 1.5014909322112258 + }, + { + "step": 543, + "lr": 0.0001, + "sup_loss": 1.5652702316615847 + }, + { + "step": 544, + "lr": 0.0001, + "sup_loss": 1.5142425507305857 + }, + { + "step": 545, + "lr": 0.0001, + "sup_loss": 1.5276751131394457 + }, + { + "step": 546, + "lr": 0.0001, + "sup_loss": 1.5245769195990062 + }, + { + "step": 547, + "lr": 0.0001, + "sup_loss": 1.5040433985839126 + }, + { + "step": 548, + "lr": 0.0001, + "sup_loss": 1.4731805883822844 + }, + { + "step": 549, + "lr": 0.0001, + "sup_loss": 1.523989010566578 + }, + { + "step": 550, + "lr": 0.0001, + "sup_loss": 1.5175207581712926, + "lyap1_mean": -10.758066177368164, + "lyap1_max": -10.607852935791016, + "lyap_spec_mean": [ + -10.75806713104248, + -11.470582962036133 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 551, + "lr": 0.0001, + "sup_loss": 1.4971526018336017 + }, + { + "step": 552, + "lr": 0.0001, + "sup_loss": 1.4895302764798874 + }, + { + "step": 553, + "lr": 0.0001, + "sup_loss": 1.5332218163992666 + }, + { + "step": 554, + "lr": 0.0001, + "sup_loss": 1.51443773185748 + }, + { + "step": 555, + "lr": 0.0001, + "sup_loss": 1.5253722163721417 + }, + { + "step": 556, + "lr": 0.0001, + "sup_loss": 1.5050382465970886 + }, + { + "step": 557, + "lr": 0.0001, + "sup_loss": 1.5370492257954307 + }, + { + "step": 558, + "lr": 0.0001, + "sup_loss": 1.4657143857688804 + }, + { + "step": 559, + "lr": 0.0001, + "sup_loss": 1.536527869346071 + }, + { + "step": 560, + "lr": 0.0001, + "sup_loss": 1.524685885669237 + }, + { + "step": 561, + "lr": 0.0001, + "sup_loss": 1.5081444758780085 + }, + { + "step": 562, + "lr": 0.0001, + "sup_loss": 1.499385660737609 + }, + { + "step": 563, + "lr": 0.0001, + "sup_loss": 1.519724938071661 + }, + { + "step": 564, + "lr": 0.0001, + "sup_loss": 1.4798648503240914 + }, + { + "step": 565, + "lr": 0.0001, + "sup_loss": 1.5273230250184124 + }, + { + "step": 566, + "lr": 0.0001, + "sup_loss": 1.521062368234926 + }, + { + "step": 567, + "lr": 0.0001, + "sup_loss": 1.5222791412642909 + }, + { + "step": 568, + "lr": 0.0001, + "sup_loss": 1.5103247563659143 + }, + { + "step": 569, + "lr": 0.0001, + "sup_loss": 1.5569352920488948 + }, + { + "step": 570, + "lr": 0.0001, + "sup_loss": 1.489553136424848 + }, + { + "step": 571, + "lr": 0.0001, + "sup_loss": 1.52472145379252 + }, + { + "step": 572, + "lr": 0.0001, + "sup_loss": 1.5210004220148543 + }, + { + "step": 573, + "lr": 0.0001, + "sup_loss": 1.554976167923613 + }, + { + "step": 574, + "lr": 0.0001, + "sup_loss": 1.4831825865229942 + }, + { + "step": 575, + "lr": 0.0001, + "sup_loss": 1.4767394761102688 + }, + { + "step": 576, + "lr": 0.0001, + "sup_loss": 1.5271143907626947 + }, + { + "step": 577, + "lr": 0.0001, + "sup_loss": 1.519121455223726 + }, + { + "step": 578, + "lr": 0.0001, + "sup_loss": 1.497157712558869 + }, + { + "step": 579, + "lr": 0.0001, + "sup_loss": 1.517625795538412 + }, + { + "step": 580, + "lr": 0.0001, + "sup_loss": 1.567087316520561 + }, + { + "step": 581, + "lr": 0.0001, + "sup_loss": 1.5069574483855266 + }, + { + "step": 582, + "lr": 0.0001, + "sup_loss": 1.5266713767839415 + }, + { + "step": 583, + "lr": 0.0001, + "sup_loss": 1.5136533102031966 + }, + { + "step": 584, + "lr": 0.0001, + "sup_loss": 1.5398053821302395 + }, + { + "step": 585, + "lr": 0.0001, + "sup_loss": 1.5207036750253404 + }, + { + "step": 586, + "lr": 0.0001, + "sup_loss": 1.5568700070402846 + }, + { + "step": 587, + "lr": 0.0001, + "sup_loss": 1.4930601848272418 + }, + { + "step": 588, + "lr": 0.0001, + "sup_loss": 1.5197131728503268 + }, + { + "step": 589, + "lr": 0.0001, + "sup_loss": 1.509870372226886 + }, + { + "step": 590, + "lr": 0.0001, + "sup_loss": 1.5605127355427801 + }, + { + "step": 591, + "lr": 0.0001, + "sup_loss": 1.5329795747053463 + }, + { + "step": 592, + "lr": 0.0001, + "sup_loss": 1.4729902400828474 + }, + { + "step": 593, + "lr": 0.0001, + "sup_loss": 1.5065587852289786 + }, + { + "step": 594, + "lr": 0.0001, + "sup_loss": 1.5162436697453585 + }, + { + "step": 595, + "lr": 0.0001, + "sup_loss": 1.501181951466543 + }, + { + "step": 596, + "lr": 0.0001, + "sup_loss": 1.5128016271192617 + }, + { + "step": 597, + "lr": 0.0001, + "sup_loss": 1.4955089560463402 + }, + { + "step": 598, + "lr": 0.0001, + "sup_loss": 1.530072364291421 + }, + { + "step": 599, + "lr": 0.0001, + "sup_loss": 1.5269364022145997 + }, + { + "step": 600, + "lr": 0.0001, + "sup_loss": 1.4752203514301139, + "lyap1_mean": -10.81710433959961, + "lyap1_max": -10.478694915771484, + "lyap_spec_mean": [ + -10.81710433959961, + -11.54246711730957 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 601, + "lr": 0.0001, + "sup_loss": 1.533622384028767 + }, + { + "step": 602, + "lr": 0.0001, + "sup_loss": 1.5294729872861208 + }, + { + "step": 603, + "lr": 0.0001, + "sup_loss": 1.5267323813111378 + }, + { + "step": 604, + "lr": 0.0001, + "sup_loss": 1.5037988005368887 + }, + { + "step": 605, + "lr": 0.0001, + "sup_loss": 1.5400566992703506 + }, + { + "step": 606, + "lr": 0.0001, + "sup_loss": 1.5194292891867367 + }, + { + "step": 607, + "lr": 0.0001, + "sup_loss": 1.5137679765290846 + }, + { + "step": 608, + "lr": 0.0001, + "sup_loss": 1.5263569481206216 + }, + { + "step": 609, + "lr": 0.0001, + "sup_loss": 1.526879212972724 + }, + { + "step": 610, + "lr": 0.0001, + "sup_loss": 1.5196563028366656 + }, + { + "step": 611, + "lr": 0.0001, + "sup_loss": 1.5264088291244253 + }, + { + "step": 612, + "lr": 0.0001, + "sup_loss": 1.5188258056963377 + }, + { + "step": 613, + "lr": 0.0001, + "sup_loss": 1.4833610200614398 + }, + { + "step": 614, + "lr": 0.0001, + "sup_loss": 1.5193956595283746 + }, + { + "step": 615, + "lr": 0.0001, + "sup_loss": 1.5095989430732548 + }, + { + "step": 616, + "lr": 0.0001, + "sup_loss": 1.4615477565895358 + }, + { + "step": 617, + "lr": 0.0001, + "sup_loss": 1.5202185730078797 + }, + { + "step": 618, + "lr": 0.0001, + "sup_loss": 1.5156975671961361 + }, + { + "step": 619, + "lr": 0.0001, + "sup_loss": 1.4955224378949017 + }, + { + "step": 620, + "lr": 0.0001, + "sup_loss": 1.5099647307638147 + }, + { + "step": 621, + "lr": 0.0001, + "sup_loss": 1.5170427436566138 + }, + { + "step": 622, + "lr": 0.0001, + "sup_loss": 1.4829578796560652 + }, + { + "step": 623, + "lr": 0.0001, + "sup_loss": 1.50918333743958 + }, + { + "step": 624, + "lr": 0.0001, + "sup_loss": 1.4180491391659908 + }, + { + "step": 625, + "lr": 0.0001, + "sup_loss": 1.5465893245313287 + }, + { + "step": 626, + "lr": 0.0001, + "sup_loss": 1.4919092553142828 + }, + { + "step": 627, + "lr": 0.0001, + "sup_loss": 1.5297118996456043 + }, + { + "step": 628, + "lr": 0.0001, + "sup_loss": 1.495986315293808 + }, + { + "step": 629, + "lr": 0.0001, + "sup_loss": 1.509888625886434 + }, + { + "step": 630, + "lr": 0.0001, + "sup_loss": 1.5541740824357826 + }, + { + "step": 631, + "lr": 0.0001, + "sup_loss": 1.5671991551040387 + }, + { + "step": 632, + "lr": 0.0001, + "sup_loss": 1.5292123928324544 + }, + { + "step": 633, + "lr": 0.0001, + "sup_loss": 1.5426588823660834 + }, + { + "step": 634, + "lr": 0.0001, + "sup_loss": 1.485453862634459 + }, + { + "step": 635, + "lr": 0.0001, + "sup_loss": 1.5019850115368816 + }, + { + "step": 636, + "lr": 0.0001, + "sup_loss": 1.4921709325170587 + }, + { + "step": 637, + "lr": 0.0001, + "sup_loss": 1.4889887552257757 + }, + { + "step": 638, + "lr": 0.0001, + "sup_loss": 1.5187691084285575 + }, + { + "step": 639, + "lr": 0.0001, + "sup_loss": 1.5239986702679065 + }, + { + "step": 640, + "lr": 0.0001, + "sup_loss": 1.5291586262015888 + }, + { + "step": 641, + "lr": 0.0001, + "sup_loss": 1.5329865261729436 + }, + { + "step": 642, + "lr": 0.0001, + "sup_loss": 1.569977579545054 + }, + { + "step": 643, + "lr": 0.0001, + "sup_loss": 1.549783921441173 + }, + { + "step": 644, + "lr": 0.0001, + "sup_loss": 1.529644188015594 + }, + { + "step": 645, + "lr": 0.0001, + "sup_loss": 1.5495971951458996 + }, + { + "step": 646, + "lr": 0.0001, + "sup_loss": 1.5296362485604438 + }, + { + "step": 647, + "lr": 0.0001, + "sup_loss": 1.516776888623355 + }, + { + "step": 648, + "lr": 0.0001, + "sup_loss": 1.5292761142052465 + }, + { + "step": 649, + "lr": 0.0001, + "sup_loss": 1.481605804893352 + }, + { + "step": 650, + "lr": 0.0001, + "sup_loss": 1.5052181313123125, + "lyap1_mean": -10.79106616973877, + "lyap1_max": -10.62818431854248, + "lyap_spec_mean": [ + -10.791065216064453, + -11.572179794311523 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 651, + "lr": 0.0001, + "sup_loss": 1.5095250202707353 + }, + { + "step": 652, + "lr": 0.0001, + "sup_loss": 1.4998246756494011 + }, + { + "step": 653, + "lr": 0.0001, + "sup_loss": 1.5165095014388827 + }, + { + "step": 654, + "lr": 0.0001, + "sup_loss": 1.4986121224686637 + }, + { + "step": 655, + "lr": 0.0001, + "sup_loss": 1.5129015032380795 + }, + { + "step": 656, + "lr": 0.0001, + "sup_loss": 1.526282616974292 + }, + { + "step": 657, + "lr": 0.0001, + "sup_loss": 1.495326416440136 + }, + { + "step": 658, + "lr": 0.0001, + "sup_loss": 1.4822267224870795 + }, + { + "step": 659, + "lr": 0.0001, + "sup_loss": 1.525825302223177 + }, + { + "step": 660, + "lr": 0.0001, + "sup_loss": 1.502477268176428 + }, + { + "step": 661, + "lr": 0.0001, + "sup_loss": 1.5464670801194278 + }, + { + "step": 662, + "lr": 0.0001, + "sup_loss": 1.5121104604205902 + }, + { + "step": 663, + "lr": 0.0001, + "sup_loss": 1.5292461415509375 + }, + { + "step": 664, + "lr": 0.0001, + "sup_loss": 1.5218161709262943 + }, + { + "step": 665, + "lr": 0.0001, + "sup_loss": 1.518429114303191 + }, + { + "step": 666, + "lr": 0.0001, + "sup_loss": 1.5124343650140128 + }, + { + "step": 667, + "lr": 0.0001, + "sup_loss": 1.5050271700136015 + }, + { + "step": 668, + "lr": 0.0001, + "sup_loss": 1.5270223812749821 + }, + { + "step": 669, + "lr": 0.0001, + "sup_loss": 1.5211433306095115 + }, + { + "step": 670, + "lr": 0.0001, + "sup_loss": 1.4967751067197244 + }, + { + "step": 671, + "lr": 0.0001, + "sup_loss": 1.5191252181902835 + }, + { + "step": 672, + "lr": 0.0001, + "sup_loss": 1.533075950141082 + }, + { + "step": 673, + "lr": 0.0001, + "sup_loss": 1.5124783238105564 + }, + { + "step": 674, + "lr": 0.0001, + "sup_loss": 1.5020065678064312 + }, + { + "step": 675, + "lr": 0.0001, + "sup_loss": 1.4718938848144771 + }, + { + "step": 676, + "lr": 0.0001, + "sup_loss": 1.532326735807271 + }, + { + "step": 677, + "lr": 0.0001, + "sup_loss": 1.5025012455984457 + }, + { + "step": 678, + "lr": 0.0001, + "sup_loss": 1.5190053274390845 + }, + { + "step": 679, + "lr": 0.0001, + "sup_loss": 1.5333022539241081 + }, + { + "step": 680, + "lr": 0.0001, + "sup_loss": 1.4858050093654533 + }, + { + "step": 681, + "lr": 0.0001, + "sup_loss": 1.508341565917674 + }, + { + "step": 682, + "lr": 0.0001, + "sup_loss": 1.5061645018044307 + }, + { + "step": 683, + "lr": 0.0001, + "sup_loss": 1.5292034039309452 + }, + { + "step": 684, + "lr": 0.0001, + "sup_loss": 1.541927427278669 + }, + { + "step": 685, + "lr": 0.0001, + "sup_loss": 1.5052998803069229 + }, + { + "step": 686, + "lr": 0.0001, + "sup_loss": 1.4983297028023375 + }, + { + "step": 687, + "lr": 0.0001, + "sup_loss": 1.5358386888016897 + }, + { + "step": 688, + "lr": 0.0001, + "sup_loss": 1.4990119225021066 + }, + { + "step": 689, + "lr": 0.0001, + "sup_loss": 1.4814685883495502 + }, + { + "step": 690, + "lr": 0.0001, + "sup_loss": 1.5163947237770283 + }, + { + "step": 691, + "lr": 0.0001, + "sup_loss": 1.528870732185826 + }, + { + "step": 692, + "lr": 0.0001, + "sup_loss": 1.511581864923819 + }, + { + "step": 693, + "lr": 0.0001, + "sup_loss": 1.5196421981658732 + }, + { + "step": 694, + "lr": 0.0001, + "sup_loss": 1.511512192764341 + }, + { + "step": 695, + "lr": 0.0001, + "sup_loss": 1.5329121893741597 + }, + { + "step": 696, + "lr": 0.0001, + "sup_loss": 1.5052262364350593 + }, + { + "step": 697, + "lr": 0.0001, + "sup_loss": 1.5014731399588575 + }, + { + "step": 698, + "lr": 0.0001, + "sup_loss": 1.5318168981770957 + }, + { + "step": 699, + "lr": 0.0001, + "sup_loss": 1.488862287191306 + }, + { + "step": 700, + "lr": 0.0001, + "sup_loss": 1.55697784964122, + "lyap1_mean": -10.804607391357422, + "lyap1_max": -10.58384895324707, + "lyap_spec_mean": [ + -10.804607391357422, + -11.663246154785156 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 701, + "lr": 0.0001, + "sup_loss": 1.529182813421109 + }, + { + "step": 702, + "lr": 0.0001, + "sup_loss": 1.5161712861556158 + }, + { + "step": 703, + "lr": 0.0001, + "sup_loss": 1.5146465248904295 + }, + { + "step": 704, + "lr": 0.0001, + "sup_loss": 1.5154857089574332 + }, + { + "step": 705, + "lr": 0.0001, + "sup_loss": 1.5327712002275256 + }, + { + "step": 706, + "lr": 0.0001, + "sup_loss": 1.5046359696722775 + }, + { + "step": 707, + "lr": 0.0001, + "sup_loss": 1.4750932345287184 + }, + { + "step": 708, + "lr": 0.0001, + "sup_loss": 1.5291139367852404 + }, + { + "step": 709, + "lr": 0.0001, + "sup_loss": 1.5356766559379944 + }, + { + "step": 710, + "lr": 0.0001, + "sup_loss": 1.52311202043396 + }, + { + "step": 711, + "lr": 0.0001, + "sup_loss": 1.5189525358120937 + }, + { + "step": 712, + "lr": 0.0001, + "sup_loss": 1.5119325984532817 + }, + { + "step": 713, + "lr": 0.0001, + "sup_loss": 1.4827629277817447 + }, + { + "step": 714, + "lr": 0.0001, + "sup_loss": 1.51270842795556 + }, + { + "step": 715, + "lr": 0.0001, + "sup_loss": 1.5161870292070179 + }, + { + "step": 716, + "lr": 0.0001, + "sup_loss": 1.5421892782500957 + }, + { + "step": 717, + "lr": 0.0001, + "sup_loss": 1.5015931869436003 + }, + { + "step": 718, + "lr": 0.0001, + "sup_loss": 1.5112513340994522 + }, + { + "step": 719, + "lr": 0.0001, + "sup_loss": 1.488745538150424 + }, + { + "step": 720, + "lr": 0.0001, + "sup_loss": 1.51878666913149 + }, + { + "step": 721, + "lr": 0.0001, + "sup_loss": 1.4983644579652984 + }, + { + "step": 722, + "lr": 0.0001, + "sup_loss": 1.5289960689695796 + }, + { + "step": 723, + "lr": 0.0001, + "sup_loss": 1.5292381749306603 + }, + { + "step": 724, + "lr": 0.0001, + "sup_loss": 1.5391319866767856 + }, + { + "step": 725, + "lr": 0.0001, + "sup_loss": 1.4849442998868232 + }, + { + "step": 726, + "lr": 0.0001, + "sup_loss": 1.5152041971808854 + }, + { + "step": 727, + "lr": 0.0001, + "sup_loss": 1.512240419605045 + }, + { + "step": 728, + "lr": 0.0001, + "sup_loss": 1.5329227835580534 + }, + { + "step": 729, + "lr": 0.0001, + "sup_loss": 1.5162379443758347 + }, + { + "step": 730, + "lr": 0.0001, + "sup_loss": 1.5162122363064547 + }, + { + "step": 731, + "lr": 0.0001, + "sup_loss": 1.5382885850686845 + }, + { + "step": 732, + "lr": 0.0001, + "sup_loss": 1.4815186575040509 + }, + { + "step": 733, + "lr": 0.0001, + "sup_loss": 1.5358293179519968 + }, + { + "step": 734, + "lr": 0.0001, + "sup_loss": 1.5288459243878267 + }, + { + "step": 735, + "lr": 0.0001, + "sup_loss": 1.5119742919694552 + }, + { + "step": 736, + "lr": 0.0001, + "sup_loss": 1.5022410754182223 + }, + { + "step": 737, + "lr": 0.0001, + "sup_loss": 1.5386172127628734 + }, + { + "step": 738, + "lr": 0.0001, + "sup_loss": 1.5182802942311613 + }, + { + "step": 739, + "lr": 0.0001, + "sup_loss": 1.5487784557477584 + }, + { + "step": 740, + "lr": 0.0001, + "sup_loss": 1.5287764719925763 + }, + { + "step": 741, + "lr": 0.0001, + "sup_loss": 1.4950540371594925 + }, + { + "step": 742, + "lr": 0.0001, + "sup_loss": 1.5287555230293786 + }, + { + "step": 743, + "lr": 0.0001, + "sup_loss": 1.5019130377289647 + }, + { + "step": 744, + "lr": 0.0001, + "sup_loss": 1.521496206828715 + }, + { + "step": 745, + "lr": 0.0001, + "sup_loss": 1.5248841628964667 + }, + { + "step": 746, + "lr": 0.0001, + "sup_loss": 1.5110152266975756 + }, + { + "step": 747, + "lr": 0.0001, + "sup_loss": 1.5050617333962355 + }, + { + "step": 748, + "lr": 0.0001, + "sup_loss": 1.5095923929374953 + }, + { + "step": 749, + "lr": 0.0001, + "sup_loss": 1.5092847147148623 + }, + { + "step": 750, + "lr": 0.0001, + "sup_loss": 1.5213463427949954, + "lyap1_mean": -10.365494728088379, + "lyap1_max": -10.14642333984375, + "lyap_spec_mean": [ + -10.365494728088379, + -11.327884674072266 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 751, + "lr": 0.0001, + "sup_loss": 1.5157271434111264 + }, + { + "step": 752, + "lr": 0.0001, + "sup_loss": 1.534761531730872 + }, + { + "step": 753, + "lr": 0.0001, + "sup_loss": 1.5155674452368593 + }, + { + "step": 754, + "lr": 0.0001, + "sup_loss": 1.5127744980528466 + }, + { + "step": 755, + "lr": 0.0001, + "sup_loss": 1.48458346203028 + }, + { + "step": 756, + "lr": 0.0001, + "sup_loss": 1.5113518181245313 + }, + { + "step": 757, + "lr": 0.0001, + "sup_loss": 1.5048985155312475 + }, + { + "step": 758, + "lr": 0.0001, + "sup_loss": 1.5019569770718066 + }, + { + "step": 759, + "lr": 0.0001, + "sup_loss": 1.5395251596087587 + }, + { + "step": 760, + "lr": 0.0001, + "sup_loss": 1.528005678971303 + }, + { + "step": 761, + "lr": 0.0001, + "sup_loss": 1.5217897051002383 + }, + { + "step": 762, + "lr": 0.0001, + "sup_loss": 1.5148302245772594 + }, + { + "step": 763, + "lr": 0.0001, + "sup_loss": 1.5209695063435513 + }, + { + "step": 764, + "lr": 0.0001, + "sup_loss": 1.5366713797774127 + }, + { + "step": 765, + "lr": 0.0001, + "sup_loss": 1.533844608316639 + }, + { + "step": 766, + "lr": 0.0001, + "sup_loss": 1.5427119830297646 + }, + { + "step": 767, + "lr": 0.0001, + "sup_loss": 1.5014029013847752 + }, + { + "step": 768, + "lr": 0.0001, + "sup_loss": 1.5106917730622813 + }, + { + "step": 769, + "lr": 0.0001, + "sup_loss": 1.518839636126279 + }, + { + "step": 770, + "lr": 0.0001, + "sup_loss": 1.5183097596964177 + }, + { + "step": 771, + "lr": 0.0001, + "sup_loss": 1.5184461741966782 + }, + { + "step": 772, + "lr": 0.0001, + "sup_loss": 1.5087977099022973 + }, + { + "step": 773, + "lr": 0.0001, + "sup_loss": 1.5117215774479997 + }, + { + "step": 774, + "lr": 0.0001, + "sup_loss": 1.541727384252763 + }, + { + "step": 775, + "lr": 0.0001, + "sup_loss": 1.4948201109435526 + }, + { + "step": 776, + "lr": 0.0001, + "sup_loss": 1.531808708020129 + }, + { + "step": 777, + "lr": 0.0001, + "sup_loss": 1.5353412428112914 + }, + { + "step": 778, + "lr": 0.0001, + "sup_loss": 1.5261955516929175 + }, + { + "step": 779, + "lr": 0.0001, + "sup_loss": 1.4941617371290674 + }, + { + "step": 780, + "lr": 0.0001, + "sup_loss": 1.5445887139366297 + }, + { + "step": 781, + "lr": 0.0001, + "sup_loss": 1.4683481347836218 + }, + { + "step": 782, + "lr": 0.0001, + "sup_loss": 1.5113164945374589 + }, + { + "step": 783, + "lr": 0.0001, + "sup_loss": 1.495137873946895 + }, + { + "step": 784, + "lr": 0.0001, + "sup_loss": 1.5298191313877383 + }, + { + "step": 785, + "lr": 0.0001, + "sup_loss": 1.5154288886919682 + }, + { + "step": 786, + "lr": 0.0001, + "sup_loss": 1.5056340275910531 + }, + { + "step": 787, + "lr": 0.0001, + "sup_loss": 1.4908429575559838 + }, + { + "step": 788, + "lr": 0.0001, + "sup_loss": 1.5111767886215024 + }, + { + "step": 789, + "lr": 0.0001, + "sup_loss": 1.5110426302611102 + }, + { + "step": 790, + "lr": 0.0001, + "sup_loss": 1.4573402183646318 + }, + { + "step": 791, + "lr": 0.0001, + "sup_loss": 1.5250452036740125 + }, + { + "step": 792, + "lr": 0.0001, + "sup_loss": 1.5561298232807879 + }, + { + "step": 793, + "lr": 0.0001, + "sup_loss": 1.5316319150705693 + }, + { + "step": 794, + "lr": 0.0001, + "sup_loss": 1.5213894826742151 + }, + { + "step": 795, + "lr": 0.0001, + "sup_loss": 1.4982122296597422 + }, + { + "step": 796, + "lr": 0.0001, + "sup_loss": 1.5077798595295027 + }, + { + "step": 797, + "lr": 0.0001, + "sup_loss": 1.4848605011801441 + }, + { + "step": 798, + "lr": 0.0001, + "sup_loss": 1.4938309140937798 + }, + { + "step": 799, + "lr": 0.0001, + "sup_loss": 1.5289565811953243 + }, + { + "step": 800, + "lr": 0.0001, + "sup_loss": 1.5214458054102131, + "lyap1_mean": -10.4353609085083, + "lyap1_max": -10.282366752624512, + "lyap_spec_mean": [ + -10.4353609085083, + -11.322216987609863 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 801, + "lr": 0.0001, + "sup_loss": 1.4814873377543591 + }, + { + "step": 802, + "lr": 0.0001, + "sup_loss": 1.5042551087130744 + }, + { + "step": 803, + "lr": 0.0001, + "sup_loss": 1.5179267508868197 + }, + { + "step": 804, + "lr": 0.0001, + "sup_loss": 1.5177964984585484 + }, + { + "step": 805, + "lr": 0.0001, + "sup_loss": 1.5388211023466885 + }, + { + "step": 806, + "lr": 0.0001, + "sup_loss": 1.5216918937936872 + }, + { + "step": 807, + "lr": 0.0001, + "sup_loss": 1.5216860563541421 + }, + { + "step": 808, + "lr": 0.0001, + "sup_loss": 1.4946585656314126 + }, + { + "step": 809, + "lr": 0.0001, + "sup_loss": 1.505771603829363 + }, + { + "step": 810, + "lr": 0.0001, + "sup_loss": 1.478309691161166 + }, + { + "step": 811, + "lr": 0.0001, + "sup_loss": 1.5217901175380344 + }, + { + "step": 812, + "lr": 0.0001, + "sup_loss": 1.5214631489340247 + }, + { + "step": 813, + "lr": 0.0001, + "sup_loss": 1.527842273002886 + }, + { + "step": 814, + "lr": 0.0001, + "sup_loss": 1.5386031272571359 + }, + { + "step": 815, + "lr": 0.0001, + "sup_loss": 1.532473693629925 + }, + { + "step": 816, + "lr": 0.0001, + "sup_loss": 1.4905039228069654 + }, + { + "step": 817, + "lr": 0.0001, + "sup_loss": 1.5143759629148181 + }, + { + "step": 818, + "lr": 0.0001, + "sup_loss": 1.4908353575327307 + }, + { + "step": 819, + "lr": 0.0001, + "sup_loss": 1.5344252499335345 + }, + { + "step": 820, + "lr": 0.0001, + "sup_loss": 1.548779810984247 + }, + { + "step": 821, + "lr": 0.0001, + "sup_loss": 1.5253148024225789 + }, + { + "step": 822, + "lr": 0.0001, + "sup_loss": 1.4976836142244427 + }, + { + "step": 823, + "lr": 0.0001, + "sup_loss": 1.4960360227125977 + }, + { + "step": 824, + "lr": 0.0001, + "sup_loss": 1.5324016930134545 + }, + { + "step": 825, + "lr": 0.0001, + "sup_loss": 1.5178845893447244 + }, + { + "step": 826, + "lr": 0.0001, + "sup_loss": 1.5250057091685358 + }, + { + "step": 827, + "lr": 0.0001, + "sup_loss": 1.5053816383483776 + }, + { + "step": 828, + "lr": 0.0001, + "sup_loss": 1.4947524095592895 + }, + { + "step": 829, + "lr": 0.0001, + "sup_loss": 1.5250796737258387 + }, + { + "step": 830, + "lr": 0.0001, + "sup_loss": 1.5450531314645986 + }, + { + "step": 831, + "lr": 0.0001, + "sup_loss": 1.5346856663516606 + }, + { + "step": 832, + "lr": 0.0001, + "sup_loss": 1.5258771238743665 + }, + { + "step": 833, + "lr": 0.0001, + "sup_loss": 1.5075100075109402 + }, + { + "step": 834, + "lr": 0.0001, + "sup_loss": 1.5198059566472084 + }, + { + "step": 835, + "lr": 0.0001, + "sup_loss": 1.516124102115623 + }, + { + "step": 836, + "lr": 0.0001, + "sup_loss": 1.5085963025232314 + }, + { + "step": 837, + "lr": 0.0001, + "sup_loss": 1.5210857846198094 + }, + { + "step": 838, + "lr": 0.0001, + "sup_loss": 1.5249432326393482 + }, + { + "step": 839, + "lr": 0.0001, + "sup_loss": 1.5420051860251147 + }, + { + "step": 840, + "lr": 0.0001, + "sup_loss": 1.4876766099221317 + }, + { + "step": 841, + "lr": 0.0001, + "sup_loss": 1.5120264948975182 + }, + { + "step": 842, + "lr": 0.0001, + "sup_loss": 1.5450506142496383 + }, + { + "step": 843, + "lr": 0.0001, + "sup_loss": 1.5362477521509854 + }, + { + "step": 844, + "lr": 0.0001, + "sup_loss": 1.522553544421977 + }, + { + "step": 845, + "lr": 0.0001, + "sup_loss": 1.5016102259073587 + }, + { + "step": 846, + "lr": 0.0001, + "sup_loss": 1.487891456966095 + }, + { + "step": 847, + "lr": 0.0001, + "sup_loss": 1.4565180287322126 + }, + { + "step": 848, + "lr": 0.0001, + "sup_loss": 1.4909856562260968 + }, + { + "step": 849, + "lr": 0.0001, + "sup_loss": 1.5137810626442132 + }, + { + "step": 850, + "lr": 0.0001, + "sup_loss": 1.535003360861764, + "lyap1_mean": -10.2115478515625, + "lyap1_max": -10.11120319366455, + "lyap_spec_mean": [ + -10.2115478515625, + -11.240118026733398 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 851, + "lr": 0.0001, + "sup_loss": 1.4682571927871104 + }, + { + "step": 852, + "lr": 0.0001, + "sup_loss": 1.5002224188110593 + }, + { + "step": 853, + "lr": 0.0001, + "sup_loss": 1.4523688352839021 + }, + { + "step": 854, + "lr": 0.0001, + "sup_loss": 1.5123564662567506 + }, + { + "step": 855, + "lr": 0.0001, + "sup_loss": 1.5312771949104442 + }, + { + "step": 856, + "lr": 0.0001, + "sup_loss": 1.4911132235799118 + }, + { + "step": 857, + "lr": 0.0001, + "sup_loss": 1.5313469945534095 + }, + { + "step": 858, + "lr": 0.0001, + "sup_loss": 1.534936278180425 + }, + { + "step": 859, + "lr": 0.0001, + "sup_loss": 1.515452156091076 + }, + { + "step": 860, + "lr": 0.0001, + "sup_loss": 1.4970374731662635 + }, + { + "step": 861, + "lr": 0.0001, + "sup_loss": 1.5078185645833702 + }, + { + "step": 862, + "lr": 0.0001, + "sup_loss": 1.5350425544968045 + }, + { + "step": 863, + "lr": 0.0001, + "sup_loss": 1.5011965992925165 + }, + { + "step": 864, + "lr": 0.0001, + "sup_loss": 1.531625924427576 + }, + { + "step": 865, + "lr": 0.0001, + "sup_loss": 1.4873875083060037 + }, + { + "step": 866, + "lr": 0.0001, + "sup_loss": 1.5105695138559807 + }, + { + "step": 867, + "lr": 0.0001, + "sup_loss": 1.4673764461804975 + }, + { + "step": 868, + "lr": 0.0001, + "sup_loss": 1.497470526944972 + }, + { + "step": 869, + "lr": 0.0001, + "sup_loss": 1.5342015402243803 + }, + { + "step": 870, + "lr": 0.0001, + "sup_loss": 1.517589125550836 + }, + { + "step": 871, + "lr": 0.0001, + "sup_loss": 1.5253814758039894 + }, + { + "step": 872, + "lr": 0.0001, + "sup_loss": 1.4770774154840078 + }, + { + "step": 873, + "lr": 0.0001, + "sup_loss": 1.5177339977326907 + }, + { + "step": 874, + "lr": 0.0001, + "sup_loss": 1.5521058021518317 + }, + { + "step": 875, + "lr": 0.0001, + "sup_loss": 1.4876248452965795 + }, + { + "step": 876, + "lr": 0.0001, + "sup_loss": 1.4939198571288062 + }, + { + "step": 877, + "lr": 0.0001, + "sup_loss": 1.521567163839101 + }, + { + "step": 878, + "lr": 0.0001, + "sup_loss": 1.5144775918664342 + }, + { + "step": 879, + "lr": 0.0001, + "sup_loss": 1.5549464851979382 + }, + { + "step": 880, + "lr": 0.0001, + "sup_loss": 1.524532676127167 + }, + { + "step": 881, + "lr": 0.0001, + "sup_loss": 1.5035667530420096 + }, + { + "step": 882, + "lr": 0.0001, + "sup_loss": 1.4703883903791422 + }, + { + "step": 883, + "lr": 0.0001, + "sup_loss": 1.5031212800747258 + }, + { + "step": 884, + "lr": 0.0001, + "sup_loss": 1.5116881798084225 + }, + { + "step": 885, + "lr": 0.0001, + "sup_loss": 1.5062025258007876 + }, + { + "step": 886, + "lr": 0.0001, + "sup_loss": 1.522219582556288 + }, + { + "step": 887, + "lr": 0.0001, + "sup_loss": 1.5203086586431591 + }, + { + "step": 888, + "lr": 0.0001, + "sup_loss": 1.4976492600579807 + }, + { + "step": 889, + "lr": 0.0001, + "sup_loss": 1.5013764319003722 + }, + { + "step": 890, + "lr": 0.0001, + "sup_loss": 1.5220576529882013 + }, + { + "step": 891, + "lr": 0.0001, + "sup_loss": 1.5180304454157 + }, + { + "step": 892, + "lr": 0.0001, + "sup_loss": 1.4937295362463094 + }, + { + "step": 893, + "lr": 0.0001, + "sup_loss": 1.5170068069019793 + }, + { + "step": 894, + "lr": 0.0001, + "sup_loss": 1.5287469850045097 + }, + { + "step": 895, + "lr": 0.0001, + "sup_loss": 1.4710172590149657 + }, + { + "step": 896, + "lr": 0.0001, + "sup_loss": 1.5205454963184943 + }, + { + "step": 897, + "lr": 0.0001, + "sup_loss": 1.4983270265031525 + }, + { + "step": 898, + "lr": 0.0001, + "sup_loss": 1.5387304056330156 + }, + { + "step": 899, + "lr": 0.0001, + "sup_loss": 1.5411767710368482 + }, + { + "step": 900, + "lr": 0.0001, + "sup_loss": 1.5023575568769916, + "lyap1_mean": -10.297163963317871, + "lyap1_max": -10.145556449890137, + "lyap_spec_mean": [ + -10.297163963317871, + -11.311446189880371 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 901, + "lr": 0.0001, + "sup_loss": 1.5109854576213162 + }, + { + "step": 902, + "lr": 0.0001, + "sup_loss": 1.5208414637898675 + }, + { + "step": 903, + "lr": 0.0001, + "sup_loss": 1.4711981539008612 + }, + { + "step": 904, + "lr": 0.0001, + "sup_loss": 1.5275393067711132 + }, + { + "step": 905, + "lr": 0.0001, + "sup_loss": 1.5344797450090302 + }, + { + "step": 906, + "lr": 0.0001, + "sup_loss": 1.5347596579431588 + }, + { + "step": 907, + "lr": 0.0001, + "sup_loss": 1.5176361721573979 + }, + { + "step": 908, + "lr": 0.0001, + "sup_loss": 1.4909805193404655 + }, + { + "step": 909, + "lr": 0.0001, + "sup_loss": 1.5038453429036809 + }, + { + "step": 910, + "lr": 0.0001, + "sup_loss": 1.487439858399984 + }, + { + "step": 911, + "lr": 0.0001, + "sup_loss": 1.4974947420197535 + }, + { + "step": 912, + "lr": 0.0001, + "sup_loss": 1.4903136629454157 + }, + { + "step": 913, + "lr": 0.0001, + "sup_loss": 1.545416287194641 + }, + { + "step": 914, + "lr": 0.0001, + "sup_loss": 1.517575744410618 + }, + { + "step": 915, + "lr": 0.0001, + "sup_loss": 1.450610183333114 + }, + { + "step": 916, + "lr": 0.0001, + "sup_loss": 1.541493121363801 + }, + { + "step": 917, + "lr": 0.0001, + "sup_loss": 1.469946223968813 + }, + { + "step": 918, + "lr": 0.0001, + "sup_loss": 1.5269957872205462 + }, + { + "step": 919, + "lr": 0.0001, + "sup_loss": 1.517771893809051 + }, + { + "step": 920, + "lr": 0.0001, + "sup_loss": 1.5011240283967675 + }, + { + "step": 921, + "lr": 0.0001, + "sup_loss": 1.5590813748738568 + }, + { + "step": 922, + "lr": 0.0001, + "sup_loss": 1.4795563569288244 + }, + { + "step": 923, + "lr": 0.0001, + "sup_loss": 1.5107349973930406 + }, + { + "step": 924, + "lr": 0.0001, + "sup_loss": 1.5105276790263353 + }, + { + "step": 925, + "lr": 0.0001, + "sup_loss": 1.4744425315567793 + }, + { + "step": 926, + "lr": 0.0001, + "sup_loss": 1.5010129998985005 + }, + { + "step": 927, + "lr": 0.0001, + "sup_loss": 1.4598719180228807 + }, + { + "step": 928, + "lr": 0.0001, + "sup_loss": 1.5314774915000235 + }, + { + "step": 929, + "lr": 0.0001, + "sup_loss": 1.5009488759550453 + }, + { + "step": 930, + "lr": 0.0001, + "sup_loss": 1.5381701181603815 + }, + { + "step": 931, + "lr": 0.0001, + "sup_loss": 1.5280688703841354 + }, + { + "step": 932, + "lr": 0.0001, + "sup_loss": 1.5146160768571129 + }, + { + "step": 933, + "lr": 0.0001, + "sup_loss": 1.5136209187054528 + }, + { + "step": 934, + "lr": 0.0001, + "sup_loss": 1.5212347568946822 + }, + { + "step": 935, + "lr": 0.0001, + "sup_loss": 1.5136310774557487 + }, + { + "step": 936, + "lr": 0.0001, + "sup_loss": 1.5166144502264525 + }, + { + "step": 937, + "lr": 0.0001, + "sup_loss": 1.5243278782056289 + }, + { + "step": 938, + "lr": 0.0001, + "sup_loss": 1.4438635854550592 + }, + { + "step": 939, + "lr": 0.0001, + "sup_loss": 1.5046012398203092 + }, + { + "step": 940, + "lr": 0.0001, + "sup_loss": 1.5058599738485512 + }, + { + "step": 941, + "lr": 0.0001, + "sup_loss": 1.5289266337819927 + }, + { + "step": 942, + "lr": 0.0001, + "sup_loss": 1.514043109825103 + }, + { + "step": 943, + "lr": 0.0001, + "sup_loss": 1.5277912631683168 + }, + { + "step": 944, + "lr": 0.0001, + "sup_loss": 1.5106536796009873 + }, + { + "step": 945, + "lr": 0.0001, + "sup_loss": 1.51011498670783 + }, + { + "step": 946, + "lr": 0.0001, + "sup_loss": 1.4769067316361997 + }, + { + "step": 947, + "lr": 0.0001, + "sup_loss": 1.5716995668970397 + }, + { + "step": 948, + "lr": 0.0001, + "sup_loss": 1.544085978621911 + }, + { + "step": 949, + "lr": 0.0001, + "sup_loss": 1.5114509171301553 + }, + { + "step": 950, + "lr": 0.0001, + "sup_loss": 1.5242237252433797, + "lyap1_mean": -10.358120918273926, + "lyap1_max": -10.184789657592773, + "lyap_spec_mean": [ + -10.358120918273926, + -11.253217697143555 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 951, + "lr": 0.0001, + "sup_loss": 1.4869588015526922 + }, + { + "step": 952, + "lr": 0.0001, + "sup_loss": 1.5375909196645314 + }, + { + "step": 953, + "lr": 0.0001, + "sup_loss": 1.5277163755874463 + }, + { + "step": 954, + "lr": 0.0001, + "sup_loss": 1.5177826748530878 + }, + { + "step": 955, + "lr": 0.0001, + "sup_loss": 1.493687747807409 + }, + { + "step": 956, + "lr": 0.0001, + "sup_loss": 1.5140592466749003 + }, + { + "step": 957, + "lr": 0.0001, + "sup_loss": 1.5140724289414524 + }, + { + "step": 958, + "lr": 0.0001, + "sup_loss": 1.524299441971118 + }, + { + "step": 959, + "lr": 0.0001, + "sup_loss": 1.5343345774761443 + }, + { + "step": 960, + "lr": 0.0001, + "sup_loss": 1.5342208978891574 + }, + { + "step": 961, + "lr": 0.0001, + "sup_loss": 1.4968766406122025 + }, + { + "step": 962, + "lr": 0.0001, + "sup_loss": 1.5280532851387352 + }, + { + "step": 963, + "lr": 0.0001, + "sup_loss": 1.508405308662308 + }, + { + "step": 964, + "lr": 0.0001, + "sup_loss": 1.5182322186861914 + }, + { + "step": 965, + "lr": 0.0001, + "sup_loss": 1.4870202169077693 + }, + { + "step": 966, + "lr": 0.0001, + "sup_loss": 1.5245849835259704 + }, + { + "step": 967, + "lr": 0.0001, + "sup_loss": 1.5336015944622983 + }, + { + "step": 968, + "lr": 0.0001, + "sup_loss": 1.5176369983189002 + }, + { + "step": 969, + "lr": 0.0001, + "sup_loss": 1.5282146546852466 + }, + { + "step": 970, + "lr": 0.0001, + "sup_loss": 1.5207952675641212 + }, + { + "step": 971, + "lr": 0.0001, + "sup_loss": 1.5142953132764574 + }, + { + "step": 972, + "lr": 0.0001, + "sup_loss": 1.5110283424503674 + }, + { + "step": 973, + "lr": 0.0001, + "sup_loss": 1.5177174844296364 + }, + { + "step": 974, + "lr": 0.0001, + "sup_loss": 1.5279808328189972 + }, + { + "step": 975, + "lr": 0.0001, + "sup_loss": 1.5108974812792109 + }, + { + "step": 976, + "lr": 0.0001, + "sup_loss": 1.5102873599549471 + }, + { + "step": 977, + "lr": 0.0001, + "sup_loss": 1.530693192946476 + }, + { + "step": 978, + "lr": 0.0001, + "sup_loss": 1.5581628743561438 + }, + { + "step": 979, + "lr": 0.0001, + "sup_loss": 1.4633263929106293 + }, + { + "step": 980, + "lr": 0.0001, + "sup_loss": 1.5682392841192343 + }, + { + "step": 981, + "lr": 0.0001, + "sup_loss": 1.4906946976182003 + }, + { + "step": 982, + "lr": 0.0001, + "sup_loss": 1.510652795630217 + }, + { + "step": 983, + "lr": 0.0001, + "sup_loss": 1.5409361944045945 + }, + { + "step": 984, + "lr": 0.0001, + "sup_loss": 1.537922758754951 + }, + { + "step": 985, + "lr": 0.0001, + "sup_loss": 1.4668831677930894 + }, + { + "step": 986, + "lr": 0.0001, + "sup_loss": 1.544940397702406 + }, + { + "step": 987, + "lr": 0.0001, + "sup_loss": 1.5013719618749788 + }, + { + "step": 988, + "lr": 0.0001, + "sup_loss": 1.5244964873111326 + }, + { + "step": 989, + "lr": 0.0001, + "sup_loss": 1.4875266219483019 + }, + { + "step": 990, + "lr": 0.0001, + "sup_loss": 1.5003623229623377 + }, + { + "step": 991, + "lr": 0.0001, + "sup_loss": 1.510510814323742 + }, + { + "step": 992, + "lr": 0.0001, + "sup_loss": 1.5002790269415267 + }, + { + "step": 993, + "lr": 0.0001, + "sup_loss": 1.483475771992361 + }, + { + "step": 994, + "lr": 0.0001, + "sup_loss": 1.5006942720886844 + }, + { + "step": 995, + "lr": 0.0001, + "sup_loss": 1.5555402221738714 + }, + { + "step": 996, + "lr": 0.0001, + "sup_loss": 1.4908621887627727 + }, + { + "step": 997, + "lr": 0.0001, + "sup_loss": 1.4912327587784586 + }, + { + "step": 998, + "lr": 0.0001, + "sup_loss": 1.5271872827015154 + }, + { + "step": 999, + "lr": 0.0001, + "sup_loss": 1.4936907974320863 + }, + { + "step": 1000, + "lr": 0.0001, + "sup_loss": 1.4973639350003876, + "lyap1_mean": -10.514686584472656, + "lyap1_max": -10.266777992248535, + "lyap_spec_mean": [ + -10.514686584472656, + -11.29997730255127 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1001, + "lr": 0.0001, + "sup_loss": 1.5073940889217172 + }, + { + "step": 1002, + "lr": 0.0001, + "sup_loss": 1.544463825004469 + }, + { + "step": 1003, + "lr": 0.0001, + "sup_loss": 1.4738591898187512 + }, + { + "step": 1004, + "lr": 0.0001, + "sup_loss": 1.510941011789433 + }, + { + "step": 1005, + "lr": 0.0001, + "sup_loss": 1.5075554662664719 + }, + { + "step": 1006, + "lr": 0.0001, + "sup_loss": 1.5315009020881578 + }, + { + "step": 1007, + "lr": 0.0001, + "sup_loss": 1.5032170348184906 + }, + { + "step": 1008, + "lr": 0.0001, + "sup_loss": 1.4985439276060195 + }, + { + "step": 1009, + "lr": 0.0001, + "sup_loss": 1.5311330711101658 + }, + { + "step": 1010, + "lr": 0.0001, + "sup_loss": 1.5205645356112503 + }, + { + "step": 1011, + "lr": 0.0001, + "sup_loss": 1.5233735198217968 + }, + { + "step": 1012, + "lr": 0.0001, + "sup_loss": 1.5040882208123314 + }, + { + "step": 1013, + "lr": 0.0001, + "sup_loss": 1.5079369444769837 + }, + { + "step": 1014, + "lr": 0.0001, + "sup_loss": 1.5135148809438879 + }, + { + "step": 1015, + "lr": 0.0001, + "sup_loss": 1.5075691724475402 + }, + { + "step": 1016, + "lr": 0.0001, + "sup_loss": 1.5240532345268807 + }, + { + "step": 1017, + "lr": 0.0001, + "sup_loss": 1.5415380040674371 + }, + { + "step": 1018, + "lr": 0.0001, + "sup_loss": 1.5076051500305356 + }, + { + "step": 1019, + "lr": 0.0001, + "sup_loss": 1.5305444251037987 + }, + { + "step": 1020, + "lr": 0.0001, + "sup_loss": 1.4903356437311586 + }, + { + "step": 1021, + "lr": 0.0001, + "sup_loss": 1.5236684936512754 + }, + { + "step": 1022, + "lr": 0.0001, + "sup_loss": 1.504507487706519 + }, + { + "step": 1023, + "lr": 0.0001, + "sup_loss": 1.4498791021087813 + }, + { + "step": 1024, + "lr": 0.0001, + "sup_loss": 1.5110422515716133 + }, + { + "step": 1025, + "lr": 0.0001, + "sup_loss": 1.5213925309746967 + }, + { + "step": 1026, + "lr": 0.0001, + "sup_loss": 1.501180068595964 + }, + { + "step": 1027, + "lr": 0.0001, + "sup_loss": 1.5342517318829239 + }, + { + "step": 1028, + "lr": 0.0001, + "sup_loss": 1.5076813997500278 + }, + { + "step": 1029, + "lr": 0.0001, + "sup_loss": 1.5142791284847685 + }, + { + "step": 1030, + "lr": 0.0001, + "sup_loss": 1.5142756085126452 + }, + { + "step": 1031, + "lr": 0.0001, + "sup_loss": 1.510280030508682 + }, + { + "step": 1032, + "lr": 0.0001, + "sup_loss": 1.4937975555266219 + }, + { + "step": 1033, + "lr": 0.0001, + "sup_loss": 1.5233726135941932 + }, + { + "step": 1034, + "lr": 0.0001, + "sup_loss": 1.5214495525318257 + }, + { + "step": 1035, + "lr": 0.0001, + "sup_loss": 1.4968815132364703 + }, + { + "step": 1036, + "lr": 0.0001, + "sup_loss": 1.4998109051965756 + }, + { + "step": 1037, + "lr": 0.0001, + "sup_loss": 1.5038833734864818 + }, + { + "step": 1038, + "lr": 0.0001, + "sup_loss": 1.5595741881848137 + }, + { + "step": 1039, + "lr": 0.0001, + "sup_loss": 1.5242356713114378 + }, + { + "step": 1040, + "lr": 0.0001, + "sup_loss": 1.4973475603192876 + }, + { + "step": 1041, + "lr": 0.0001, + "sup_loss": 1.521409796844551 + }, + { + "step": 1042, + "lr": 0.0001, + "sup_loss": 1.5003568204573885 + }, + { + "step": 1043, + "lr": 0.0001, + "sup_loss": 1.515094730544753 + }, + { + "step": 1044, + "lr": 0.0001, + "sup_loss": 1.5380390259911096 + }, + { + "step": 1045, + "lr": 0.0001, + "sup_loss": 1.5206647407976805 + }, + { + "step": 1046, + "lr": 0.0001, + "sup_loss": 1.5136010098490627 + }, + { + "step": 1047, + "lr": 0.0001, + "sup_loss": 1.5199676557405792 + }, + { + "step": 1048, + "lr": 0.0001, + "sup_loss": 1.5169618200232688 + }, + { + "step": 1049, + "lr": 0.0001, + "sup_loss": 1.503622973622402 + }, + { + "step": 1050, + "lr": 0.0001, + "sup_loss": 1.4800350241203735, + "lyap1_mean": -10.48875904083252, + "lyap1_max": -10.14209270477295, + "lyap_spec_mean": [ + -10.48875904083252, + -11.288721084594727 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1051, + "lr": 0.0001, + "sup_loss": 1.5272025636091806 + }, + { + "step": 1052, + "lr": 0.0001, + "sup_loss": 1.5205926153445293 + }, + { + "step": 1053, + "lr": 0.0001, + "sup_loss": 1.5585274707824792 + }, + { + "step": 1054, + "lr": 0.0001, + "sup_loss": 1.513778751661253 + }, + { + "step": 1055, + "lr": 0.0001, + "sup_loss": 1.5018987930032344 + }, + { + "step": 1056, + "lr": 0.0001, + "sup_loss": 1.5227274000219528 + }, + { + "step": 1057, + "lr": 0.0001, + "sup_loss": 1.5211424367575703 + }, + { + "step": 1058, + "lr": 0.0001, + "sup_loss": 1.5023955375590274 + }, + { + "step": 1059, + "lr": 0.0001, + "sup_loss": 1.540841371386507 + }, + { + "step": 1060, + "lr": 0.0001, + "sup_loss": 1.5316149956410103 + }, + { + "step": 1061, + "lr": 0.0001, + "sup_loss": 1.4969879106590227 + }, + { + "step": 1062, + "lr": 0.0001, + "sup_loss": 1.5103571309689134 + }, + { + "step": 1063, + "lr": 0.0001, + "sup_loss": 1.5063094416633365 + }, + { + "step": 1064, + "lr": 0.0001, + "sup_loss": 1.4969149671866473 + }, + { + "step": 1065, + "lr": 0.0001, + "sup_loss": 1.5174092005529476 + }, + { + "step": 1066, + "lr": 0.0001, + "sup_loss": 1.5204245805600276 + }, + { + "step": 1067, + "lr": 0.0001, + "sup_loss": 1.5103452144204705 + }, + { + "step": 1068, + "lr": 0.0001, + "sup_loss": 1.517080564153666 + }, + { + "step": 1069, + "lr": 0.0001, + "sup_loss": 1.4724400210903543 + }, + { + "step": 1070, + "lr": 0.0001, + "sup_loss": 1.5166704269234852 + }, + { + "step": 1071, + "lr": 0.0001, + "sup_loss": 1.5279256447161207 + }, + { + "step": 1072, + "lr": 0.0001, + "sup_loss": 1.5061720849644094 + }, + { + "step": 1073, + "lr": 0.0001, + "sup_loss": 1.5106250375919277 + }, + { + "step": 1074, + "lr": 0.0001, + "sup_loss": 1.5180297156519056 + }, + { + "step": 1075, + "lr": 0.0001, + "sup_loss": 1.4884990179149893 + }, + { + "step": 1076, + "lr": 0.0001, + "sup_loss": 1.5321261268788053 + }, + { + "step": 1077, + "lr": 0.0001, + "sup_loss": 1.5104686412307335 + }, + { + "step": 1078, + "lr": 0.0001, + "sup_loss": 1.4910582828164736 + }, + { + "step": 1079, + "lr": 0.0001, + "sup_loss": 1.5071801230693216 + }, + { + "step": 1080, + "lr": 0.0001, + "sup_loss": 1.5174735814885238 + }, + { + "step": 1081, + "lr": 0.0001, + "sup_loss": 1.5106753166911289 + }, + { + "step": 1082, + "lr": 0.0001, + "sup_loss": 1.5234376008864305 + }, + { + "step": 1083, + "lr": 0.0001, + "sup_loss": 1.4930751150763013 + }, + { + "step": 1084, + "lr": 0.0001, + "sup_loss": 1.5147959516882767 + }, + { + "step": 1085, + "lr": 0.0001, + "sup_loss": 1.5209347552165153 + }, + { + "step": 1086, + "lr": 0.0001, + "sup_loss": 1.50644536374663 + }, + { + "step": 1087, + "lr": 0.0001, + "sup_loss": 1.5514516469109434 + }, + { + "step": 1088, + "lr": 0.0001, + "sup_loss": 1.5341170091900043 + }, + { + "step": 1089, + "lr": 0.0001, + "sup_loss": 1.513796698789378 + }, + { + "step": 1090, + "lr": 0.0001, + "sup_loss": 1.4801056605187524 + }, + { + "step": 1091, + "lr": 0.0001, + "sup_loss": 1.4966319137967188 + }, + { + "step": 1092, + "lr": 0.0001, + "sup_loss": 1.4899085549590863 + }, + { + "step": 1093, + "lr": 0.0001, + "sup_loss": 1.4801109080368169 + }, + { + "step": 1094, + "lr": 0.0001, + "sup_loss": 1.4589603373372586 + }, + { + "step": 1095, + "lr": 0.0001, + "sup_loss": 1.5582077268375976 + }, + { + "step": 1096, + "lr": 0.0001, + "sup_loss": 1.489836545689724 + }, + { + "step": 1097, + "lr": 0.0001, + "sup_loss": 1.5241535913472757 + }, + { + "step": 1098, + "lr": 0.0001, + "sup_loss": 1.5266109750616894 + }, + { + "step": 1099, + "lr": 0.0001, + "sup_loss": 1.5343256739193865 + }, + { + "step": 1100, + "lr": 0.0001, + "sup_loss": 1.529762880122655, + "lyap1_mean": -10.641798973083496, + "lyap1_max": -10.386137008666992, + "lyap_spec_mean": [ + -10.641798973083496, + -11.142293930053711 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1101, + "lr": 0.0001, + "sup_loss": 1.520818660628841 + }, + { + "step": 1102, + "lr": 0.0001, + "sup_loss": 1.5006465654297256 + }, + { + "step": 1103, + "lr": 0.0001, + "sup_loss": 1.5104708630018062 + }, + { + "step": 1104, + "lr": 0.0001, + "sup_loss": 1.5172540123742746 + }, + { + "step": 1105, + "lr": 0.0001, + "sup_loss": 1.5036072480614382 + }, + { + "step": 1106, + "lr": 0.0001, + "sup_loss": 1.5455496808774247 + }, + { + "step": 1107, + "lr": 0.0001, + "sup_loss": 1.5304535729869255 + }, + { + "step": 1108, + "lr": 0.0001, + "sup_loss": 1.554694642787004 + }, + { + "step": 1109, + "lr": 0.0001, + "sup_loss": 1.5195131419107535 + }, + { + "step": 1110, + "lr": 0.0001, + "sup_loss": 1.516729056568863 + }, + { + "step": 1111, + "lr": 0.0001, + "sup_loss": 1.514220705197893 + }, + { + "step": 1112, + "lr": 0.0001, + "sup_loss": 1.439216468595088 + }, + { + "step": 1113, + "lr": 0.0001, + "sup_loss": 1.5273479572271167 + }, + { + "step": 1114, + "lr": 0.0001, + "sup_loss": 1.5131659466211045 + }, + { + "step": 1115, + "lr": 0.0001, + "sup_loss": 1.5590201121375922 + }, + { + "step": 1116, + "lr": 0.0001, + "sup_loss": 1.513057675220298 + }, + { + "step": 1117, + "lr": 0.0001, + "sup_loss": 1.5168576837151553 + }, + { + "step": 1118, + "lr": 0.0001, + "sup_loss": 1.5100721298895876 + }, + { + "step": 1119, + "lr": 0.0001, + "sup_loss": 1.517645538693279 + }, + { + "step": 1120, + "lr": 0.0001, + "sup_loss": 1.4881981640741304 + }, + { + "step": 1121, + "lr": 0.0001, + "sup_loss": 1.5107571288838597 + }, + { + "step": 1122, + "lr": 0.0001, + "sup_loss": 1.5070020741769181 + }, + { + "step": 1123, + "lr": 0.0001, + "sup_loss": 1.5266019711113752 + }, + { + "step": 1124, + "lr": 0.0001, + "sup_loss": 1.496003846339376 + }, + { + "step": 1125, + "lr": 0.0001, + "sup_loss": 1.5074121014316855 + }, + { + "step": 1126, + "lr": 0.0001, + "sup_loss": 1.493549940818824 + }, + { + "step": 1127, + "lr": 0.0001, + "sup_loss": 1.5135345048639777 + }, + { + "step": 1128, + "lr": 0.0001, + "sup_loss": 1.5142460506647937 + }, + { + "step": 1129, + "lr": 0.0001, + "sup_loss": 1.5206142528626299 + }, + { + "step": 1130, + "lr": 0.0001, + "sup_loss": 1.5003567830923654 + }, + { + "step": 1131, + "lr": 0.0001, + "sup_loss": 1.527390240174164 + }, + { + "step": 1132, + "lr": 0.0001, + "sup_loss": 1.4963879513227982 + }, + { + "step": 1133, + "lr": 0.0001, + "sup_loss": 1.4867799629076504 + }, + { + "step": 1134, + "lr": 0.0001, + "sup_loss": 1.4840619255960934 + }, + { + "step": 1135, + "lr": 0.0001, + "sup_loss": 1.4933716027716504 + }, + { + "step": 1136, + "lr": 0.0001, + "sup_loss": 1.531036115489307 + }, + { + "step": 1137, + "lr": 0.0001, + "sup_loss": 1.5375903461724822 + }, + { + "step": 1138, + "lr": 0.0001, + "sup_loss": 1.5182574550008072 + }, + { + "step": 1139, + "lr": 0.0001, + "sup_loss": 1.497075131707928 + }, + { + "step": 1140, + "lr": 0.0001, + "sup_loss": 1.5278479415331627 + }, + { + "step": 1141, + "lr": 0.0001, + "sup_loss": 1.520515351022875 + }, + { + "step": 1142, + "lr": 0.0001, + "sup_loss": 1.5016851240990374 + }, + { + "step": 1143, + "lr": 0.0001, + "sup_loss": 1.5245503977727506 + }, + { + "step": 1144, + "lr": 0.0001, + "sup_loss": 1.531674227529005 + }, + { + "step": 1145, + "lr": 0.0001, + "sup_loss": 1.5136410368326192 + }, + { + "step": 1146, + "lr": 0.0001, + "sup_loss": 1.5039991083522324 + }, + { + "step": 1147, + "lr": 0.0001, + "sup_loss": 1.5136498077798672 + }, + { + "step": 1148, + "lr": 0.0001, + "sup_loss": 1.5001547319480508 + }, + { + "step": 1149, + "lr": 0.0001, + "sup_loss": 1.528253369692847 + }, + { + "step": 1150, + "lr": 0.0001, + "sup_loss": 1.5104587191249514, + "lyap1_mean": -10.477584838867188, + "lyap1_max": -10.266040802001953, + "lyap_spec_mean": [ + -10.477584838867188, + -11.391194343566895 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1151, + "lr": 0.0001, + "sup_loss": 1.4821131362551936 + }, + { + "step": 1152, + "lr": 0.0001, + "sup_loss": 1.5312549756329086 + }, + { + "step": 1153, + "lr": 0.0001, + "sup_loss": 1.4766076155250443 + }, + { + "step": 1154, + "lr": 0.0001, + "sup_loss": 1.520339766126558 + }, + { + "step": 1155, + "lr": 0.0001, + "sup_loss": 1.5271643974402285 + }, + { + "step": 1156, + "lr": 0.0001, + "sup_loss": 1.533871365743686 + }, + { + "step": 1157, + "lr": 0.0001, + "sup_loss": 1.5710268205798492 + }, + { + "step": 1158, + "lr": 0.0001, + "sup_loss": 1.5068768153124819 + }, + { + "step": 1159, + "lr": 0.0001, + "sup_loss": 1.5140275354524169 + }, + { + "step": 1160, + "lr": 0.0001, + "sup_loss": 1.5243116272917698 + }, + { + "step": 1161, + "lr": 0.0001, + "sup_loss": 1.520870453755664 + }, + { + "step": 1162, + "lr": 0.0001, + "sup_loss": 1.5233592471102273 + }, + { + "step": 1163, + "lr": 0.0001, + "sup_loss": 1.4977805927106946 + }, + { + "step": 1164, + "lr": 0.0001, + "sup_loss": 1.5331554938445429 + }, + { + "step": 1165, + "lr": 0.0001, + "sup_loss": 1.4876600928892616 + }, + { + "step": 1166, + "lr": 0.0001, + "sup_loss": 1.5244620694614963 + }, + { + "step": 1167, + "lr": 0.0001, + "sup_loss": 1.4797271958557663 + }, + { + "step": 1168, + "lr": 0.0001, + "sup_loss": 1.522034846203957 + }, + { + "step": 1169, + "lr": 0.0001, + "sup_loss": 1.5002823371910519 + }, + { + "step": 1170, + "lr": 0.0001, + "sup_loss": 1.5204950192815379 + }, + { + "step": 1171, + "lr": 0.0001, + "sup_loss": 1.4764679503431613 + }, + { + "step": 1172, + "lr": 0.0001, + "sup_loss": 1.513772432945491 + }, + { + "step": 1173, + "lr": 0.0001, + "sup_loss": 1.5376524610692368 + }, + { + "step": 1174, + "lr": 0.0001, + "sup_loss": 1.4967023899908238 + }, + { + "step": 1175, + "lr": 0.0001, + "sup_loss": 1.5270210483811808 + }, + { + "step": 1176, + "lr": 0.0001, + "sup_loss": 1.5201838060838075 + }, + { + "step": 1177, + "lr": 0.0001, + "sup_loss": 1.5275505762323611 + }, + { + "step": 1178, + "lr": 0.0001, + "sup_loss": 1.5007030404952633 + }, + { + "step": 1179, + "lr": 0.0001, + "sup_loss": 1.5175150651880427 + }, + { + "step": 1180, + "lr": 0.0001, + "sup_loss": 1.4869591379402938 + }, + { + "step": 1181, + "lr": 0.0001, + "sup_loss": 1.4937698684488179 + }, + { + "step": 1182, + "lr": 0.0001, + "sup_loss": 1.5032411784745094 + }, + { + "step": 1183, + "lr": 0.0001, + "sup_loss": 1.5114630471038324 + }, + { + "step": 1184, + "lr": 0.0001, + "sup_loss": 1.5411341736836435 + }, + { + "step": 1185, + "lr": 0.0001, + "sup_loss": 1.51382404206819 + }, + { + "step": 1186, + "lr": 0.0001, + "sup_loss": 1.50374798036288 + }, + { + "step": 1187, + "lr": 0.0001, + "sup_loss": 1.513468438006399 + }, + { + "step": 1188, + "lr": 0.0001, + "sup_loss": 1.466293811029661 + }, + { + "step": 1189, + "lr": 0.0001, + "sup_loss": 1.496986440923877 + }, + { + "step": 1190, + "lr": 0.0001, + "sup_loss": 1.527998535775542 + }, + { + "step": 1191, + "lr": 0.0001, + "sup_loss": 1.5142054793623356 + }, + { + "step": 1192, + "lr": 0.0001, + "sup_loss": 1.517126396545784 + }, + { + "step": 1193, + "lr": 0.0001, + "sup_loss": 1.5407380667989397 + }, + { + "step": 1194, + "lr": 0.0001, + "sup_loss": 1.486733693309315 + }, + { + "step": 1195, + "lr": 0.0001, + "sup_loss": 1.493060752390878 + }, + { + "step": 1196, + "lr": 0.0001, + "sup_loss": 1.5197894520326458 + }, + { + "step": 1197, + "lr": 0.0001, + "sup_loss": 1.4595610179398977 + }, + { + "step": 1198, + "lr": 0.0001, + "sup_loss": 1.5244107263549567 + }, + { + "step": 1199, + "lr": 0.0001, + "sup_loss": 1.5229276041572963 + }, + { + "step": 1200, + "lr": 0.0001, + "sup_loss": 1.4868504938973006, + "lyap1_mean": -10.821054458618164, + "lyap1_max": -10.430198669433594, + "lyap_spec_mean": [ + -10.821054458618164, + -11.424166679382324 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1201, + "lr": 0.0001, + "sup_loss": 1.5303461242986895 + }, + { + "step": 1202, + "lr": 0.0001, + "sup_loss": 1.518109327851075 + }, + { + "step": 1203, + "lr": 0.0001, + "sup_loss": 1.4297514042932784 + }, + { + "step": 1204, + "lr": 0.0001, + "sup_loss": 1.5213388871331008 + }, + { + "step": 1205, + "lr": 0.0001, + "sup_loss": 1.5137987468176843 + }, + { + "step": 1206, + "lr": 0.0001, + "sup_loss": 1.5238073326732706 + }, + { + "step": 1207, + "lr": 0.0001, + "sup_loss": 1.499894998088831 + }, + { + "step": 1208, + "lr": 0.0001, + "sup_loss": 1.4901996656645264 + }, + { + "step": 1209, + "lr": 0.0001, + "sup_loss": 1.4858403179771866 + }, + { + "step": 1210, + "lr": 0.0001, + "sup_loss": 1.52980950840394 + }, + { + "step": 1211, + "lr": 0.0001, + "sup_loss": 1.5199694179929903 + }, + { + "step": 1212, + "lr": 0.0001, + "sup_loss": 1.5244928880017599 + }, + { + "step": 1213, + "lr": 0.0001, + "sup_loss": 1.4648735265552526 + }, + { + "step": 1214, + "lr": 0.0001, + "sup_loss": 1.5000539920972715 + }, + { + "step": 1215, + "lr": 0.0001, + "sup_loss": 1.4348231164100225 + }, + { + "step": 1216, + "lr": 0.0001, + "sup_loss": 1.4963114300272795 + }, + { + "step": 1217, + "lr": 0.0001, + "sup_loss": 1.5179608251207573 + }, + { + "step": 1218, + "lr": 0.0001, + "sup_loss": 1.4834007623165668 + }, + { + "step": 1219, + "lr": 0.0001, + "sup_loss": 1.506268927421157 + }, + { + "step": 1220, + "lr": 0.0001, + "sup_loss": 1.518170747451819 + }, + { + "step": 1221, + "lr": 0.0001, + "sup_loss": 1.4974395224037238 + }, + { + "step": 1222, + "lr": 0.0001, + "sup_loss": 1.4487977563167826 + }, + { + "step": 1223, + "lr": 0.0001, + "sup_loss": 1.5240394324145075 + }, + { + "step": 1224, + "lr": 0.0001, + "sup_loss": 1.5408679025934726 + }, + { + "step": 1225, + "lr": 0.0001, + "sup_loss": 1.5107275783354157 + }, + { + "step": 1226, + "lr": 0.0001, + "sup_loss": 1.5100202852646094 + }, + { + "step": 1227, + "lr": 0.0001, + "sup_loss": 1.554076592606299 + }, + { + "step": 1228, + "lr": 0.0001, + "sup_loss": 1.5283768381898672 + }, + { + "step": 1229, + "lr": 0.0001, + "sup_loss": 1.5103696337775578 + }, + { + "step": 1230, + "lr": 0.0001, + "sup_loss": 1.5160359142392286 + }, + { + "step": 1231, + "lr": 0.0001, + "sup_loss": 1.512616442178945 + }, + { + "step": 1232, + "lr": 0.0001, + "sup_loss": 1.5075565610779549 + }, + { + "step": 1233, + "lr": 0.0001, + "sup_loss": 1.50985125060074 + }, + { + "step": 1234, + "lr": 0.0001, + "sup_loss": 1.5036201958179265 + }, + { + "step": 1235, + "lr": 0.0001, + "sup_loss": 1.536654246122191 + }, + { + "step": 1236, + "lr": 0.0001, + "sup_loss": 1.5144692666133364 + }, + { + "step": 1237, + "lr": 0.0001, + "sup_loss": 1.4844832670968178 + }, + { + "step": 1238, + "lr": 0.0001, + "sup_loss": 1.466735198982158 + }, + { + "step": 1239, + "lr": 0.0001, + "sup_loss": 1.5410083242929136 + }, + { + "step": 1240, + "lr": 0.0001, + "sup_loss": 1.52761500585601 + }, + { + "step": 1241, + "lr": 0.0001, + "sup_loss": 1.5206344872792525 + }, + { + "step": 1242, + "lr": 0.0001, + "sup_loss": 1.516456349315079 + }, + { + "step": 1243, + "lr": 0.0001, + "sup_loss": 1.5035736058784535 + }, + { + "step": 1244, + "lr": 0.0001, + "sup_loss": 1.5165946425479495 + }, + { + "step": 1245, + "lr": 0.0001, + "sup_loss": 1.530468162982282 + }, + { + "step": 1246, + "lr": 0.0001, + "sup_loss": 1.519539882674977 + }, + { + "step": 1247, + "lr": 0.0001, + "sup_loss": 1.4997542125156402 + }, + { + "step": 1248, + "lr": 0.0001, + "sup_loss": 1.496302410803664 + }, + { + "step": 1249, + "lr": 0.0001, + "sup_loss": 1.5103728859307508 + }, + { + "step": 1250, + "lr": 0.0001, + "sup_loss": 1.5107784630427152, + "lyap1_mean": -10.645218849182129, + "lyap1_max": -10.434868812561035, + "lyap_spec_mean": [ + -10.645218849182129, + -11.488506317138672 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1251, + "lr": 0.0001, + "sup_loss": 1.4976111801398138 + }, + { + "step": 1252, + "lr": 0.0001, + "sup_loss": 1.510350153698212 + }, + { + "step": 1253, + "lr": 0.0001, + "sup_loss": 1.5437645760088192 + }, + { + "step": 1254, + "lr": 0.0001, + "sup_loss": 1.5306254844900191 + }, + { + "step": 1255, + "lr": 0.0001, + "sup_loss": 1.5170390561138314 + }, + { + "step": 1256, + "lr": 0.0001, + "sup_loss": 1.49599520098554 + }, + { + "step": 1257, + "lr": 0.0001, + "sup_loss": 1.520838778814498 + }, + { + "step": 1258, + "lr": 0.0001, + "sup_loss": 1.4854921351824049 + }, + { + "step": 1259, + "lr": 0.0001, + "sup_loss": 1.472941466156597 + }, + { + "step": 1260, + "lr": 0.0001, + "sup_loss": 1.5091105311739912 + }, + { + "step": 1261, + "lr": 0.0001, + "sup_loss": 1.4874715203196052 + }, + { + "step": 1262, + "lr": 0.0001, + "sup_loss": 1.5028014768505682 + }, + { + "step": 1263, + "lr": 0.0001, + "sup_loss": 1.5135444460842602 + }, + { + "step": 1264, + "lr": 0.0001, + "sup_loss": 1.524737207227631 + }, + { + "step": 1265, + "lr": 0.0001, + "sup_loss": 1.518069595826668 + }, + { + "step": 1266, + "lr": 0.0001, + "sup_loss": 1.5516894047393028 + }, + { + "step": 1267, + "lr": 0.0001, + "sup_loss": 1.4591796731140907 + }, + { + "step": 1268, + "lr": 0.0001, + "sup_loss": 1.5303950285520527 + }, + { + "step": 1269, + "lr": 0.0001, + "sup_loss": 1.5274031932545629 + }, + { + "step": 1270, + "lr": 0.0001, + "sup_loss": 1.5475652478266813 + }, + { + "step": 1271, + "lr": 0.0001, + "sup_loss": 1.4797438771387414 + }, + { + "step": 1272, + "lr": 0.0001, + "sup_loss": 1.550635498775946 + }, + { + "step": 1273, + "lr": 0.0001, + "sup_loss": 1.5099982615822942 + }, + { + "step": 1274, + "lr": 0.0001, + "sup_loss": 1.5166235371567525 + }, + { + "step": 1275, + "lr": 0.0001, + "sup_loss": 1.4898968716101946 + }, + { + "step": 1276, + "lr": 0.0001, + "sup_loss": 1.4967371174883406 + }, + { + "step": 1277, + "lr": 0.0001, + "sup_loss": 1.5142452514021802 + }, + { + "step": 1278, + "lr": 0.0001, + "sup_loss": 1.4800989942886318 + }, + { + "step": 1279, + "lr": 0.0001, + "sup_loss": 1.5005613167969696 + }, + { + "step": 1280, + "lr": 0.0001, + "sup_loss": 1.5096950435731598 + }, + { + "step": 1281, + "lr": 0.0001, + "sup_loss": 1.4967517413790135 + }, + { + "step": 1282, + "lr": 0.0001, + "sup_loss": 1.5271242427568812 + }, + { + "step": 1283, + "lr": 0.0001, + "sup_loss": 1.46926402885785 + }, + { + "step": 1284, + "lr": 0.0001, + "sup_loss": 1.5009915063698456 + }, + { + "step": 1285, + "lr": 0.0001, + "sup_loss": 1.5066263379555889 + }, + { + "step": 1286, + "lr": 0.0001, + "sup_loss": 1.5144783320719515 + }, + { + "step": 1287, + "lr": 0.0001, + "sup_loss": 1.5340405467735512 + }, + { + "step": 1288, + "lr": 0.0001, + "sup_loss": 1.5508888027725807 + }, + { + "step": 1289, + "lr": 0.0001, + "sup_loss": 1.5378374955967107 + }, + { + "step": 1290, + "lr": 0.0001, + "sup_loss": 1.4895920164712924 + }, + { + "step": 1291, + "lr": 0.0001, + "sup_loss": 1.5275505962501166 + }, + { + "step": 1292, + "lr": 0.0001, + "sup_loss": 1.5136906897323108 + }, + { + "step": 1293, + "lr": 0.0001, + "sup_loss": 1.5065987785827668 + }, + { + "step": 1294, + "lr": 0.0001, + "sup_loss": 1.4821369685935684 + }, + { + "step": 1295, + "lr": 0.0001, + "sup_loss": 1.5275506810209658 + }, + { + "step": 1296, + "lr": 0.0001, + "sup_loss": 1.5414360205505984 + }, + { + "step": 1297, + "lr": 0.0001, + "sup_loss": 1.4969468354580895 + }, + { + "step": 1298, + "lr": 0.0001, + "sup_loss": 1.5532970357356997 + }, + { + "step": 1299, + "lr": 0.0001, + "sup_loss": 1.5139822518112103 + }, + { + "step": 1300, + "lr": 0.0001, + "sup_loss": 1.5069592416575903, + "lyap1_mean": -10.710769653320312, + "lyap1_max": -10.560123443603516, + "lyap_spec_mean": [ + -10.710770606994629, + -11.567009925842285 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1301, + "lr": 0.0001, + "sup_loss": 1.4997549968200834 + }, + { + "step": 1302, + "lr": 0.0001, + "sup_loss": 1.5538790189142884 + }, + { + "step": 1303, + "lr": 0.0001, + "sup_loss": 1.5264470796504657 + }, + { + "step": 1304, + "lr": 0.0001, + "sup_loss": 1.5337258434357997 + }, + { + "step": 1305, + "lr": 0.0001, + "sup_loss": 1.5853794700875345 + }, + { + "step": 1306, + "lr": 0.0001, + "sup_loss": 1.5064744052505328 + }, + { + "step": 1307, + "lr": 0.0001, + "sup_loss": 1.513668556255632 + }, + { + "step": 1308, + "lr": 0.0001, + "sup_loss": 1.4562545938466445 + }, + { + "step": 1309, + "lr": 0.0001, + "sup_loss": 1.527232471603875 + }, + { + "step": 1310, + "lr": 0.0001, + "sup_loss": 1.4792007423233202 + }, + { + "step": 1311, + "lr": 0.0001, + "sup_loss": 1.4974391216965157 + }, + { + "step": 1312, + "lr": 0.0001, + "sup_loss": 1.5168112737407995 + }, + { + "step": 1313, + "lr": 0.0001, + "sup_loss": 1.510068087051874 + }, + { + "step": 1314, + "lr": 0.0001, + "sup_loss": 1.5337691215261238 + }, + { + "step": 1315, + "lr": 0.0001, + "sup_loss": 1.5165348732461628 + }, + { + "step": 1316, + "lr": 0.0001, + "sup_loss": 1.5242524540330815 + }, + { + "step": 1317, + "lr": 0.0001, + "sup_loss": 1.537555120462959 + }, + { + "step": 1318, + "lr": 0.0001, + "sup_loss": 1.5200519798956444 + }, + { + "step": 1319, + "lr": 0.0001, + "sup_loss": 1.5572906252644723 + }, + { + "step": 1320, + "lr": 0.0001, + "sup_loss": 1.5231984888316223 + }, + { + "step": 1321, + "lr": 0.0001, + "sup_loss": 1.5062709168230792 + }, + { + "step": 1322, + "lr": 0.0001, + "sup_loss": 1.5140948781275025 + }, + { + "step": 1323, + "lr": 0.0001, + "sup_loss": 1.5072616973518564 + }, + { + "step": 1324, + "lr": 0.0001, + "sup_loss": 1.5074072546160904 + }, + { + "step": 1325, + "lr": 0.0001, + "sup_loss": 1.5474699516695087 + }, + { + "step": 1326, + "lr": 0.0001, + "sup_loss": 1.4963163621865216 + }, + { + "step": 1327, + "lr": 0.0001, + "sup_loss": 1.4802933624251058 + }, + { + "step": 1328, + "lr": 0.0001, + "sup_loss": 1.496441607868229 + }, + { + "step": 1329, + "lr": 0.0001, + "sup_loss": 1.4999290298246852 + }, + { + "step": 1330, + "lr": 0.0001, + "sup_loss": 1.4969298463835763 + }, + { + "step": 1331, + "lr": 0.0001, + "sup_loss": 1.5335308771930647 + }, + { + "step": 1332, + "lr": 0.0001, + "sup_loss": 1.4935685345706808 + }, + { + "step": 1333, + "lr": 0.0001, + "sup_loss": 1.4933103106271741 + }, + { + "step": 1334, + "lr": 0.0001, + "sup_loss": 1.5172474059316696 + }, + { + "step": 1335, + "lr": 0.0001, + "sup_loss": 1.4525455563204457 + }, + { + "step": 1336, + "lr": 0.0001, + "sup_loss": 1.5305496035441197 + }, + { + "step": 1337, + "lr": 0.0001, + "sup_loss": 1.4928096047575736 + }, + { + "step": 1338, + "lr": 0.0001, + "sup_loss": 1.5028687127780258 + }, + { + "step": 1339, + "lr": 0.0001, + "sup_loss": 1.5166916763907838 + }, + { + "step": 1340, + "lr": 0.0001, + "sup_loss": 1.5270323699811439 + }, + { + "step": 1341, + "lr": 0.0001, + "sup_loss": 1.5201634204443186 + }, + { + "step": 1342, + "lr": 0.0001, + "sup_loss": 1.4968670718373327 + }, + { + "step": 1343, + "lr": 0.0001, + "sup_loss": 1.5302544837148928 + }, + { + "step": 1344, + "lr": 0.0001, + "sup_loss": 1.5437978799059817 + }, + { + "step": 1345, + "lr": 0.0001, + "sup_loss": 1.5091520096565627 + }, + { + "step": 1346, + "lr": 0.0001, + "sup_loss": 1.507267651303871 + }, + { + "step": 1347, + "lr": 0.0001, + "sup_loss": 1.5097438519727575 + }, + { + "step": 1348, + "lr": 0.0001, + "sup_loss": 1.5337337785530207 + }, + { + "step": 1349, + "lr": 0.0001, + "sup_loss": 1.4928830028036728 + }, + { + "step": 1350, + "lr": 0.0001, + "sup_loss": 1.5167475241745552, + "lyap1_mean": -10.756025314331055, + "lyap1_max": -10.599478721618652, + "lyap_spec_mean": [ + -10.756025314331055, + -11.619546890258789 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1351, + "lr": 0.0001, + "sup_loss": 1.5132877941261855 + }, + { + "step": 1352, + "lr": 0.0001, + "sup_loss": 1.4998524170694583 + }, + { + "step": 1353, + "lr": 0.0001, + "sup_loss": 1.4964681651610476 + }, + { + "step": 1354, + "lr": 0.0001, + "sup_loss": 1.523780240090228 + }, + { + "step": 1355, + "lr": 0.0001, + "sup_loss": 1.5134572774699877 + }, + { + "step": 1356, + "lr": 0.0001, + "sup_loss": 1.523701127384147 + }, + { + "step": 1357, + "lr": 0.0001, + "sup_loss": 1.4826831081663778 + }, + { + "step": 1358, + "lr": 0.0001, + "sup_loss": 1.489101442228866 + }, + { + "step": 1359, + "lr": 0.0001, + "sup_loss": 1.5337381929563387 + }, + { + "step": 1360, + "lr": 0.0001, + "sup_loss": 1.523609039644293 + }, + { + "step": 1361, + "lr": 0.0001, + "sup_loss": 1.5300903667413235 + }, + { + "step": 1362, + "lr": 0.0001, + "sup_loss": 1.5340221476706037 + }, + { + "step": 1363, + "lr": 0.0001, + "sup_loss": 1.5096892453203667 + }, + { + "step": 1364, + "lr": 0.0001, + "sup_loss": 1.5306723627659446 + }, + { + "step": 1365, + "lr": 0.0001, + "sup_loss": 1.517983905423166 + }, + { + "step": 1366, + "lr": 0.0001, + "sup_loss": 1.514550996461246 + }, + { + "step": 1367, + "lr": 0.0001, + "sup_loss": 1.5381001728882597 + }, + { + "step": 1368, + "lr": 0.0001, + "sup_loss": 1.5202694516311086 + }, + { + "step": 1369, + "lr": 0.0001, + "sup_loss": 1.540922894876823 + }, + { + "step": 1370, + "lr": 0.0001, + "sup_loss": 1.43938767497114 + }, + { + "step": 1371, + "lr": 0.0001, + "sup_loss": 1.550329714953283 + }, + { + "step": 1372, + "lr": 0.0001, + "sup_loss": 1.5162888125758986 + }, + { + "step": 1373, + "lr": 0.0001, + "sup_loss": 1.5302514286534266 + }, + { + "step": 1374, + "lr": 0.0001, + "sup_loss": 1.5306425072242158 + }, + { + "step": 1375, + "lr": 0.0001, + "sup_loss": 1.5376976834049185 + }, + { + "step": 1376, + "lr": 0.0001, + "sup_loss": 1.5180055870060358 + }, + { + "step": 1377, + "lr": 0.0001, + "sup_loss": 1.5064911616887144 + }, + { + "step": 1378, + "lr": 0.0001, + "sup_loss": 1.4858374612136402 + }, + { + "step": 1379, + "lr": 0.0001, + "sup_loss": 1.5068031978563456 + }, + { + "step": 1380, + "lr": 0.0001, + "sup_loss": 1.5037595295400765 + }, + { + "step": 1381, + "lr": 0.0001, + "sup_loss": 1.4497843022777839 + }, + { + "step": 1382, + "lr": 0.0001, + "sup_loss": 1.5172033123634552 + }, + { + "step": 1383, + "lr": 0.0001, + "sup_loss": 1.5063538360209956 + }, + { + "step": 1384, + "lr": 0.0001, + "sup_loss": 1.5032213806412227 + }, + { + "step": 1385, + "lr": 0.0001, + "sup_loss": 1.4921385765287527 + }, + { + "step": 1386, + "lr": 0.0001, + "sup_loss": 1.5101262684696397 + }, + { + "step": 1387, + "lr": 0.0001, + "sup_loss": 1.5061251585554216 + }, + { + "step": 1388, + "lr": 0.0001, + "sup_loss": 1.511438115128675 + }, + { + "step": 1389, + "lr": 0.0001, + "sup_loss": 1.517195044699206 + }, + { + "step": 1390, + "lr": 0.0001, + "sup_loss": 1.5096512687392971 + }, + { + "step": 1391, + "lr": 0.0001, + "sup_loss": 1.5308632360936216 + }, + { + "step": 1392, + "lr": 0.0001, + "sup_loss": 1.497700854237975 + }, + { + "step": 1393, + "lr": 0.0001, + "sup_loss": 1.50994047432534 + }, + { + "step": 1394, + "lr": 0.0001, + "sup_loss": 1.493986293536929 + }, + { + "step": 1395, + "lr": 0.0001, + "sup_loss": 1.5405767348145123 + }, + { + "step": 1396, + "lr": 0.0001, + "sup_loss": 1.5570772505888102 + }, + { + "step": 1397, + "lr": 0.0001, + "sup_loss": 1.479177977332931 + }, + { + "step": 1398, + "lr": 0.0001, + "sup_loss": 1.473023115311275 + }, + { + "step": 1399, + "lr": 0.0001, + "sup_loss": 1.5334118239870425 + }, + { + "step": 1400, + "lr": 0.0001, + "sup_loss": 1.5209411682922194, + "lyap1_mean": -10.839595794677734, + "lyap1_max": -10.633600234985352, + "lyap_spec_mean": [ + -10.839594841003418, + -11.527544021606445 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1401, + "lr": 0.0001, + "sup_loss": 1.4926184424978264 + }, + { + "step": 1402, + "lr": 0.0001, + "sup_loss": 1.5127407390032876 + }, + { + "step": 1403, + "lr": 0.0001, + "sup_loss": 1.4758884473389282 + }, + { + "step": 1404, + "lr": 0.0001, + "sup_loss": 1.5035471230967525 + }, + { + "step": 1405, + "lr": 0.0001, + "sup_loss": 1.5346356605229434 + }, + { + "step": 1406, + "lr": 0.0001, + "sup_loss": 1.5132485682935337 + }, + { + "step": 1407, + "lr": 0.0001, + "sup_loss": 1.5163802157583863 + }, + { + "step": 1408, + "lr": 0.0001, + "sup_loss": 1.5102673840995504 + }, + { + "step": 1409, + "lr": 0.0001, + "sup_loss": 1.5232766491365932 + }, + { + "step": 1410, + "lr": 0.0001, + "sup_loss": 1.5069633651708403 + }, + { + "step": 1411, + "lr": 0.0001, + "sup_loss": 1.502949425836952 + }, + { + "step": 1412, + "lr": 0.0001, + "sup_loss": 1.5228312720745476 + }, + { + "step": 1413, + "lr": 0.0001, + "sup_loss": 1.5269397730566434 + }, + { + "step": 1414, + "lr": 0.0001, + "sup_loss": 1.5094421110497127 + }, + { + "step": 1415, + "lr": 0.0001, + "sup_loss": 1.4966239347597692 + }, + { + "step": 1416, + "lr": 0.0001, + "sup_loss": 1.492071492922958 + }, + { + "step": 1417, + "lr": 0.0001, + "sup_loss": 1.5371870225231705 + }, + { + "step": 1418, + "lr": 0.0001, + "sup_loss": 1.5618148611301768 + }, + { + "step": 1419, + "lr": 0.0001, + "sup_loss": 1.5231443979076156 + }, + { + "step": 1420, + "lr": 0.0001, + "sup_loss": 1.4876756943457576 + }, + { + "step": 1421, + "lr": 0.0001, + "sup_loss": 1.4965575642308941 + }, + { + "step": 1422, + "lr": 0.0001, + "sup_loss": 1.5135288786724876 + }, + { + "step": 1423, + "lr": 0.0001, + "sup_loss": 1.4966117724897432 + }, + { + "step": 1424, + "lr": 0.0001, + "sup_loss": 1.5167129439518627 + }, + { + "step": 1425, + "lr": 0.0001, + "sup_loss": 1.5168620340864474 + }, + { + "step": 1426, + "lr": 0.0001, + "sup_loss": 1.5065856485544349 + }, + { + "step": 1427, + "lr": 0.0001, + "sup_loss": 1.5099009208575584 + }, + { + "step": 1428, + "lr": 0.0001, + "sup_loss": 1.4927170720448122 + }, + { + "step": 1429, + "lr": 0.0001, + "sup_loss": 1.5061297197839674 + }, + { + "step": 1430, + "lr": 0.0001, + "sup_loss": 1.499185701230378 + }, + { + "step": 1431, + "lr": 0.0001, + "sup_loss": 1.4728664863717993 + }, + { + "step": 1432, + "lr": 0.0001, + "sup_loss": 1.4788389757200588 + }, + { + "step": 1433, + "lr": 0.0001, + "sup_loss": 1.5185025415764604 + }, + { + "step": 1434, + "lr": 0.0001, + "sup_loss": 1.5106561808821297 + }, + { + "step": 1435, + "lr": 0.0001, + "sup_loss": 1.4939901259162827 + }, + { + "step": 1436, + "lr": 0.0001, + "sup_loss": 1.5155883597573516 + }, + { + "step": 1437, + "lr": 0.0001, + "sup_loss": 1.5121881310413057 + }, + { + "step": 1438, + "lr": 0.0001, + "sup_loss": 1.5070489858954186 + }, + { + "step": 1439, + "lr": 0.0001, + "sup_loss": 1.4926588300674835 + }, + { + "step": 1440, + "lr": 0.0001, + "sup_loss": 1.5033093127861614 + }, + { + "step": 1441, + "lr": 0.0001, + "sup_loss": 1.4757855877504757 + }, + { + "step": 1442, + "lr": 0.0001, + "sup_loss": 1.5097967946773738 + }, + { + "step": 1443, + "lr": 0.0001, + "sup_loss": 1.49934289108629 + }, + { + "step": 1444, + "lr": 0.0001, + "sup_loss": 1.4688221612418306 + }, + { + "step": 1445, + "lr": 0.0001, + "sup_loss": 1.5106066387535921 + }, + { + "step": 1446, + "lr": 0.0001, + "sup_loss": 1.5125560826298983 + }, + { + "step": 1447, + "lr": 0.0001, + "sup_loss": 1.5102537064125874 + }, + { + "step": 1448, + "lr": 0.0001, + "sup_loss": 1.5377897360789812 + }, + { + "step": 1449, + "lr": 0.0001, + "sup_loss": 1.5164211013866546 + }, + { + "step": 1450, + "lr": 0.0001, + "sup_loss": 1.5333729336736122, + "lyap1_mean": -10.881546974182129, + "lyap1_max": -10.591238021850586, + "lyap_spec_mean": [ + -10.881546020507812, + -11.589456558227539 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1451, + "lr": 0.0001, + "sup_loss": 1.5377595650572007 + }, + { + "step": 1452, + "lr": 0.0001, + "sup_loss": 1.4938637530976135 + }, + { + "step": 1453, + "lr": 0.0001, + "sup_loss": 1.485357308244127 + }, + { + "step": 1454, + "lr": 0.0001, + "sup_loss": 1.5309801263148481 + }, + { + "step": 1455, + "lr": 0.0001, + "sup_loss": 1.5268525740979126 + }, + { + "step": 1456, + "lr": 0.0001, + "sup_loss": 1.537046723993115 + }, + { + "step": 1457, + "lr": 0.0001, + "sup_loss": 1.5066023701032403 + }, + { + "step": 1458, + "lr": 0.0001, + "sup_loss": 1.526509971158013 + }, + { + "step": 1459, + "lr": 0.0001, + "sup_loss": 1.483289357737817 + }, + { + "step": 1460, + "lr": 0.0001, + "sup_loss": 1.520970082899898 + }, + { + "step": 1461, + "lr": 0.0001, + "sup_loss": 1.5208767518172586 + }, + { + "step": 1462, + "lr": 0.0001, + "sup_loss": 1.5201749468493415 + }, + { + "step": 1463, + "lr": 0.0001, + "sup_loss": 1.5237536003725036 + }, + { + "step": 1464, + "lr": 0.0001, + "sup_loss": 1.4857121136170688 + }, + { + "step": 1465, + "lr": 0.0001, + "sup_loss": 1.508995845216981 + }, + { + "step": 1466, + "lr": 0.0001, + "sup_loss": 1.5103444126568175 + }, + { + "step": 1467, + "lr": 0.0001, + "sup_loss": 1.5135398162779836 + }, + { + "step": 1468, + "lr": 0.0001, + "sup_loss": 1.5102486183591461 + }, + { + "step": 1469, + "lr": 0.0001, + "sup_loss": 1.5000258193170024 + }, + { + "step": 1470, + "lr": 0.0001, + "sup_loss": 1.5125700070607135 + }, + { + "step": 1471, + "lr": 0.0001, + "sup_loss": 1.530756644934505 + }, + { + "step": 1472, + "lr": 0.0001, + "sup_loss": 1.5162526446881293 + }, + { + "step": 1473, + "lr": 0.0001, + "sup_loss": 1.52716808861625 + }, + { + "step": 1474, + "lr": 0.0001, + "sup_loss": 1.4621953338674487 + }, + { + "step": 1475, + "lr": 0.0001, + "sup_loss": 1.5342463182610142 + }, + { + "step": 1476, + "lr": 0.0001, + "sup_loss": 1.5313130931684893 + }, + { + "step": 1477, + "lr": 0.0001, + "sup_loss": 1.509097513530669 + }, + { + "step": 1478, + "lr": 0.0001, + "sup_loss": 1.5171839647088528 + }, + { + "step": 1479, + "lr": 0.0001, + "sup_loss": 1.4830660907867792 + }, + { + "step": 1480, + "lr": 0.0001, + "sup_loss": 1.5169692839950746 + }, + { + "step": 1481, + "lr": 0.0001, + "sup_loss": 1.5096950760627834 + }, + { + "step": 1482, + "lr": 0.0001, + "sup_loss": 1.5237273754823817 + }, + { + "step": 1483, + "lr": 0.0001, + "sup_loss": 1.5169950128026808 + }, + { + "step": 1484, + "lr": 0.0001, + "sup_loss": 1.486464655741263 + }, + { + "step": 1485, + "lr": 0.0001, + "sup_loss": 1.4995075094043673 + }, + { + "step": 1486, + "lr": 0.0001, + "sup_loss": 1.4895546478113244 + }, + { + "step": 1487, + "lr": 0.0001, + "sup_loss": 1.5093014664818258 + }, + { + "step": 1488, + "lr": 0.0001, + "sup_loss": 1.516900546914382 + }, + { + "step": 1489, + "lr": 0.0001, + "sup_loss": 1.5173310230470929 + }, + { + "step": 1490, + "lr": 0.0001, + "sup_loss": 1.5062465681918806 + }, + { + "step": 1491, + "lr": 0.0001, + "sup_loss": 1.4859032697449375 + }, + { + "step": 1492, + "lr": 0.0001, + "sup_loss": 1.5136962818089519 + }, + { + "step": 1493, + "lr": 0.0001, + "sup_loss": 1.533013349893898 + }, + { + "step": 1494, + "lr": 0.0001, + "sup_loss": 1.5270248570973775 + }, + { + "step": 1495, + "lr": 0.0001, + "sup_loss": 1.5150049034118969 + }, + { + "step": 1496, + "lr": 0.0001, + "sup_loss": 1.5126701190166119 + }, + { + "step": 1497, + "lr": 0.0001, + "sup_loss": 1.5036203770551568 + }, + { + "step": 1498, + "lr": 0.0001, + "sup_loss": 1.5301773374466578 + }, + { + "step": 1499, + "lr": 0.0001, + "sup_loss": 1.4519813221132694 + }, + { + "step": 1500, + "lr": 0.0001, + "sup_loss": 1.468631745699784, + "lyap1_mean": -11.001667022705078, + "lyap1_max": -10.627558708190918, + "lyap_spec_mean": [ + -11.001666069030762, + -11.605794906616211 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1501, + "lr": 0.0001, + "sup_loss": 1.4723696373242847 + }, + { + "step": 1502, + "lr": 0.0001, + "sup_loss": 1.5070478285724638 + }, + { + "step": 1503, + "lr": 0.0001, + "sup_loss": 1.4897881105792503 + }, + { + "step": 1504, + "lr": 0.0001, + "sup_loss": 1.522933043845968 + }, + { + "step": 1505, + "lr": 0.0001, + "sup_loss": 1.5095221335302038 + }, + { + "step": 1506, + "lr": 0.0001, + "sup_loss": 1.5164698010852753 + }, + { + "step": 1507, + "lr": 0.0001, + "sup_loss": 1.5029977390994158 + }, + { + "step": 1508, + "lr": 0.0001, + "sup_loss": 1.476646989713 + }, + { + "step": 1509, + "lr": 0.0001, + "sup_loss": 1.5227442946694465 + }, + { + "step": 1510, + "lr": 0.0001, + "sup_loss": 1.5180405200022304 + }, + { + "step": 1511, + "lr": 0.0001, + "sup_loss": 1.5199896180237527 + }, + { + "step": 1512, + "lr": 0.0001, + "sup_loss": 1.418770350278989 + }, + { + "step": 1513, + "lr": 0.0001, + "sup_loss": 1.513798446091538 + }, + { + "step": 1514, + "lr": 0.0001, + "sup_loss": 1.5309517025875723 + }, + { + "step": 1515, + "lr": 0.0001, + "sup_loss": 1.5236802454279827 + }, + { + "step": 1516, + "lr": 0.0001, + "sup_loss": 1.526699481973296 + }, + { + "step": 1517, + "lr": 0.0001, + "sup_loss": 1.5164408429780412 + }, + { + "step": 1518, + "lr": 0.0001, + "sup_loss": 1.5135452350536458 + }, + { + "step": 1519, + "lr": 0.0001, + "sup_loss": 1.5176179884340533 + }, + { + "step": 1520, + "lr": 0.0001, + "sup_loss": 1.5246820825918408 + }, + { + "step": 1521, + "lr": 0.0001, + "sup_loss": 1.5234525318838334 + }, + { + "step": 1522, + "lr": 0.0001, + "sup_loss": 1.5095493214219668 + }, + { + "step": 1523, + "lr": 0.0001, + "sup_loss": 1.5467531034260558 + }, + { + "step": 1524, + "lr": 0.0001, + "sup_loss": 1.5266446044619746 + }, + { + "step": 1525, + "lr": 0.0001, + "sup_loss": 1.5131726260563918 + }, + { + "step": 1526, + "lr": 0.0001, + "sup_loss": 1.4990227729329735 + }, + { + "step": 1527, + "lr": 0.0001, + "sup_loss": 1.4988202612832684 + }, + { + "step": 1528, + "lr": 0.0001, + "sup_loss": 1.5472169363876136 + }, + { + "step": 1529, + "lr": 0.0001, + "sup_loss": 1.5408185356890496 + }, + { + "step": 1530, + "lr": 0.0001, + "sup_loss": 1.5575246415810002 + }, + { + "step": 1531, + "lr": 0.0001, + "sup_loss": 1.5234086435331706 + }, + { + "step": 1532, + "lr": 0.0001, + "sup_loss": 1.5236606179845933 + }, + { + "step": 1533, + "lr": 0.0001, + "sup_loss": 1.5367165609974094 + }, + { + "step": 1534, + "lr": 0.0001, + "sup_loss": 1.5133149802870245 + }, + { + "step": 1535, + "lr": 0.0001, + "sup_loss": 1.4926495943751155 + }, + { + "step": 1536, + "lr": 0.0001, + "sup_loss": 1.5502674225360626 + }, + { + "step": 1537, + "lr": 0.0001, + "sup_loss": 1.5199076027190006 + }, + { + "step": 1538, + "lr": 0.0001, + "sup_loss": 1.4901199455338379 + }, + { + "step": 1539, + "lr": 0.0001, + "sup_loss": 1.5369915574611437 + }, + { + "step": 1540, + "lr": 0.0001, + "sup_loss": 1.5069577478163398 + }, + { + "step": 1541, + "lr": 0.0001, + "sup_loss": 1.5136343169297541 + }, + { + "step": 1542, + "lr": 0.0001, + "sup_loss": 1.5000871920444678 + }, + { + "step": 1543, + "lr": 0.0001, + "sup_loss": 1.4802163281699736 + }, + { + "step": 1544, + "lr": 0.0001, + "sup_loss": 1.516809959243847 + }, + { + "step": 1545, + "lr": 0.0001, + "sup_loss": 1.5296557137698272 + }, + { + "step": 1546, + "lr": 0.0001, + "sup_loss": 1.479863614282976 + }, + { + "step": 1547, + "lr": 0.0001, + "sup_loss": 1.5367117003407995 + }, + { + "step": 1548, + "lr": 0.0001, + "sup_loss": 1.5039622026235653 + }, + { + "step": 1549, + "lr": 0.0001, + "sup_loss": 1.5090042864619058 + }, + { + "step": 1550, + "lr": 0.0001, + "sup_loss": 1.5233412591045794, + "lyap1_mean": -10.809311866760254, + "lyap1_max": -10.359489440917969, + "lyap_spec_mean": [ + -10.809310913085938, + -11.446893692016602 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1551, + "lr": 0.0001, + "sup_loss": 1.4959574446197252 + }, + { + "step": 1552, + "lr": 0.0001, + "sup_loss": 1.5303522429017742 + }, + { + "step": 1553, + "lr": 0.0001, + "sup_loss": 1.4939373860084944 + }, + { + "step": 1554, + "lr": 0.0001, + "sup_loss": 1.516303200065238 + }, + { + "step": 1555, + "lr": 0.0001, + "sup_loss": 1.5130535702987986 + }, + { + "step": 1556, + "lr": 0.0001, + "sup_loss": 1.4827778811379138 + }, + { + "step": 1557, + "lr": 0.0001, + "sup_loss": 1.5065780030619071 + }, + { + "step": 1558, + "lr": 0.0001, + "sup_loss": 1.5138020243413697 + }, + { + "step": 1559, + "lr": 0.0001, + "sup_loss": 1.5139048555924635 + }, + { + "step": 1560, + "lr": 0.0001, + "sup_loss": 1.5237180011432254 + }, + { + "step": 1561, + "lr": 0.0001, + "sup_loss": 1.5101266507964013 + }, + { + "step": 1562, + "lr": 0.0001, + "sup_loss": 1.5131091513238073 + }, + { + "step": 1563, + "lr": 0.0001, + "sup_loss": 1.493322702284227 + }, + { + "step": 1564, + "lr": 0.0001, + "sup_loss": 1.5201876191492487 + }, + { + "step": 1565, + "lr": 0.0001, + "sup_loss": 1.503553010451075 + }, + { + "step": 1566, + "lr": 0.0001, + "sup_loss": 1.5333948716421755 + }, + { + "step": 1567, + "lr": 0.0001, + "sup_loss": 1.5001519448276885 + }, + { + "step": 1568, + "lr": 0.0001, + "sup_loss": 1.4924266848967265 + }, + { + "step": 1569, + "lr": 0.0001, + "sup_loss": 1.5438996623290744 + }, + { + "step": 1570, + "lr": 0.0001, + "sup_loss": 1.5236302359077283 + }, + { + "step": 1571, + "lr": 0.0001, + "sup_loss": 1.5093167629292783 + }, + { + "step": 1572, + "lr": 0.0001, + "sup_loss": 1.466438471470282 + }, + { + "step": 1573, + "lr": 0.0001, + "sup_loss": 1.5090517873131297 + }, + { + "step": 1574, + "lr": 0.0001, + "sup_loss": 1.5140196947568199 + }, + { + "step": 1575, + "lr": 0.0001, + "sup_loss": 1.4995318773471806 + }, + { + "step": 1576, + "lr": 0.0001, + "sup_loss": 1.506116490443191 + }, + { + "step": 1577, + "lr": 0.0001, + "sup_loss": 1.4997731337084599 + }, + { + "step": 1578, + "lr": 0.0001, + "sup_loss": 1.5308399220951325 + }, + { + "step": 1579, + "lr": 0.0001, + "sup_loss": 1.5172829868355948 + }, + { + "step": 1580, + "lr": 0.0001, + "sup_loss": 1.5131118402692323 + }, + { + "step": 1581, + "lr": 0.0001, + "sup_loss": 1.506263966091762 + }, + { + "step": 1582, + "lr": 0.0001, + "sup_loss": 1.4920749398710706 + }, + { + "step": 1583, + "lr": 0.0001, + "sup_loss": 1.5306609804773845 + }, + { + "step": 1584, + "lr": 0.0001, + "sup_loss": 1.499934532443336 + }, + { + "step": 1585, + "lr": 0.0001, + "sup_loss": 1.5075950473992505 + }, + { + "step": 1586, + "lr": 0.0001, + "sup_loss": 1.5278714379382559 + }, + { + "step": 1587, + "lr": 0.0001, + "sup_loss": 1.5166775869423563 + }, + { + "step": 1588, + "lr": 0.0001, + "sup_loss": 1.520155811606897 + }, + { + "step": 1589, + "lr": 0.0001, + "sup_loss": 1.5197717524476568 + }, + { + "step": 1590, + "lr": 0.0001, + "sup_loss": 1.5299832933857842 + }, + { + "step": 1591, + "lr": 0.0001, + "sup_loss": 1.48244028840325 + }, + { + "step": 1592, + "lr": 0.0001, + "sup_loss": 1.513259149462762 + }, + { + "step": 1593, + "lr": 0.0001, + "sup_loss": 1.5093215303593368 + }, + { + "step": 1594, + "lr": 0.0001, + "sup_loss": 1.5369787833635793 + }, + { + "step": 1595, + "lr": 0.0001, + "sup_loss": 1.4652762125720111 + }, + { + "step": 1596, + "lr": 0.0001, + "sup_loss": 1.5199659886996684 + }, + { + "step": 1597, + "lr": 0.0001, + "sup_loss": 1.5269785984957909 + }, + { + "step": 1598, + "lr": 0.0001, + "sup_loss": 1.485939340492489 + }, + { + "step": 1599, + "lr": 0.0001, + "sup_loss": 1.5271601262884078 + }, + { + "step": 1600, + "lr": 0.0001, + "sup_loss": 1.5027044156815834, + "lyap1_mean": -10.53994369506836, + "lyap1_max": -10.287631034851074, + "lyap_spec_mean": [ + -10.53994369506836, + -11.317733764648438 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1601, + "lr": 0.0001, + "sup_loss": 1.513694886771049 + }, + { + "step": 1602, + "lr": 0.0001, + "sup_loss": 1.498839831528073 + }, + { + "step": 1603, + "lr": 0.0001, + "sup_loss": 1.5034575240072487 + }, + { + "step": 1604, + "lr": 0.0001, + "sup_loss": 1.4823676405065054 + }, + { + "step": 1605, + "lr": 0.0001, + "sup_loss": 1.4655917166080419 + }, + { + "step": 1606, + "lr": 0.0001, + "sup_loss": 1.5405933423829448 + }, + { + "step": 1607, + "lr": 0.0001, + "sup_loss": 1.5368377768997057 + }, + { + "step": 1608, + "lr": 0.0001, + "sup_loss": 1.5406045293719874 + }, + { + "step": 1609, + "lr": 0.0001, + "sup_loss": 1.5404603069330622 + }, + { + "step": 1610, + "lr": 0.0001, + "sup_loss": 1.476057281939865 + }, + { + "step": 1611, + "lr": 0.0001, + "sup_loss": 1.5130167474572762 + }, + { + "step": 1612, + "lr": 0.0001, + "sup_loss": 1.4731248817998381 + }, + { + "step": 1613, + "lr": 0.0001, + "sup_loss": 1.499145381937623 + }, + { + "step": 1614, + "lr": 0.0001, + "sup_loss": 1.4960471810586111 + }, + { + "step": 1615, + "lr": 0.0001, + "sup_loss": 1.5234576361304126 + }, + { + "step": 1616, + "lr": 0.0001, + "sup_loss": 1.5225464338514587 + }, + { + "step": 1617, + "lr": 0.0001, + "sup_loss": 1.5097606886937136 + }, + { + "step": 1618, + "lr": 0.0001, + "sup_loss": 1.530230547967843 + }, + { + "step": 1619, + "lr": 0.0001, + "sup_loss": 1.4906739023026059 + }, + { + "step": 1620, + "lr": 0.0001, + "sup_loss": 1.5208212757968977 + }, + { + "step": 1621, + "lr": 0.0001, + "sup_loss": 1.5301733778817805 + }, + { + "step": 1622, + "lr": 0.0001, + "sup_loss": 1.5398522373183638 + }, + { + "step": 1623, + "lr": 0.0001, + "sup_loss": 1.496054200639765 + }, + { + "step": 1624, + "lr": 0.0001, + "sup_loss": 1.5031501962171783 + }, + { + "step": 1625, + "lr": 0.0001, + "sup_loss": 1.5269335265540238 + }, + { + "step": 1626, + "lr": 0.0001, + "sup_loss": 1.4965395007438445 + }, + { + "step": 1627, + "lr": 0.0001, + "sup_loss": 1.520187863227331 + }, + { + "step": 1628, + "lr": 0.0001, + "sup_loss": 1.5534691606872966 + }, + { + "step": 1629, + "lr": 0.0001, + "sup_loss": 1.5468749456249298 + }, + { + "step": 1630, + "lr": 0.0001, + "sup_loss": 1.530772940000934 + }, + { + "step": 1631, + "lr": 0.0001, + "sup_loss": 1.5204312527802746 + }, + { + "step": 1632, + "lr": 0.0001, + "sup_loss": 1.5264603560212404 + }, + { + "step": 1633, + "lr": 0.0001, + "sup_loss": 1.4863259170661463 + }, + { + "step": 1634, + "lr": 0.0001, + "sup_loss": 1.5133508009389016 + }, + { + "step": 1635, + "lr": 0.0001, + "sup_loss": 1.5396208854636153 + }, + { + "step": 1636, + "lr": 0.0001, + "sup_loss": 1.5174272015126287 + }, + { + "step": 1637, + "lr": 0.0001, + "sup_loss": 1.5163403901858887 + }, + { + "step": 1638, + "lr": 0.0001, + "sup_loss": 1.5007346868573708 + }, + { + "step": 1639, + "lr": 0.0001, + "sup_loss": 1.516573672722873 + }, + { + "step": 1640, + "lr": 0.0001, + "sup_loss": 1.5092517670650947 + }, + { + "step": 1641, + "lr": 0.0001, + "sup_loss": 1.5198533362551563 + }, + { + "step": 1642, + "lr": 0.0001, + "sup_loss": 1.5129341837521504 + }, + { + "step": 1643, + "lr": 0.0001, + "sup_loss": 1.496432205798251 + }, + { + "step": 1644, + "lr": 0.0001, + "sup_loss": 1.5066479285208425 + }, + { + "step": 1645, + "lr": 0.0001, + "sup_loss": 1.5063853049144205 + }, + { + "step": 1646, + "lr": 0.0001, + "sup_loss": 1.5159650664700934 + }, + { + "step": 1647, + "lr": 0.0001, + "sup_loss": 1.48681446390825 + }, + { + "step": 1648, + "lr": 0.0001, + "sup_loss": 1.5402678471221838 + }, + { + "step": 1649, + "lr": 0.0001, + "sup_loss": 1.4487274906091623 + }, + { + "step": 1650, + "lr": 0.0001, + "sup_loss": 1.5370786164721753, + "lyap1_mean": -10.553204536437988, + "lyap1_max": -10.418966293334961, + "lyap_spec_mean": [ + -10.553204536437988, + -11.082437515258789 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1651, + "lr": 0.0001, + "sup_loss": 1.5053547277929242 + }, + { + "step": 1652, + "lr": 0.0001, + "sup_loss": 1.5200939059256757 + }, + { + "step": 1653, + "lr": 0.0001, + "sup_loss": 1.5083491019031627 + }, + { + "step": 1654, + "lr": 0.0001, + "sup_loss": 1.4970110740271705 + }, + { + "step": 1655, + "lr": 0.0001, + "sup_loss": 1.4935374548000058 + }, + { + "step": 1656, + "lr": 0.0001, + "sup_loss": 1.517560293750486 + }, + { + "step": 1657, + "lr": 0.0001, + "sup_loss": 1.5137279054478445 + }, + { + "step": 1658, + "lr": 0.0001, + "sup_loss": 1.4966175325217035 + }, + { + "step": 1659, + "lr": 0.0001, + "sup_loss": 1.499015394487407 + }, + { + "step": 1660, + "lr": 0.0001, + "sup_loss": 1.4754693933305358 + }, + { + "step": 1661, + "lr": 0.0001, + "sup_loss": 1.527832887622633 + }, + { + "step": 1662, + "lr": 0.0001, + "sup_loss": 1.5170190895722797 + }, + { + "step": 1663, + "lr": 0.0001, + "sup_loss": 1.5408173607238864 + }, + { + "step": 1664, + "lr": 0.0001, + "sup_loss": 1.5267094902743177 + }, + { + "step": 1665, + "lr": 0.0001, + "sup_loss": 1.523571777603639 + }, + { + "step": 1666, + "lr": 0.0001, + "sup_loss": 1.5434833822024931 + }, + { + "step": 1667, + "lr": 0.0001, + "sup_loss": 1.4557437648013296 + }, + { + "step": 1668, + "lr": 0.0001, + "sup_loss": 1.5229956437800936 + }, + { + "step": 1669, + "lr": 0.0001, + "sup_loss": 1.513290085751912 + }, + { + "step": 1670, + "lr": 0.0001, + "sup_loss": 1.5134002284680208 + }, + { + "step": 1671, + "lr": 0.0001, + "sup_loss": 1.5473653551106994 + }, + { + "step": 1672, + "lr": 0.0001, + "sup_loss": 1.5194259787541744 + }, + { + "step": 1673, + "lr": 0.0001, + "sup_loss": 1.5064409797149017 + }, + { + "step": 1674, + "lr": 0.0001, + "sup_loss": 1.5308548380176292 + }, + { + "step": 1675, + "lr": 0.0001, + "sup_loss": 1.4790676812386048 + }, + { + "step": 1676, + "lr": 0.0001, + "sup_loss": 1.5166160163930835 + }, + { + "step": 1677, + "lr": 0.0001, + "sup_loss": 1.495918097932609 + }, + { + "step": 1678, + "lr": 0.0001, + "sup_loss": 1.5167798020982959 + }, + { + "step": 1679, + "lr": 0.0001, + "sup_loss": 1.5094467449466475 + }, + { + "step": 1680, + "lr": 0.0001, + "sup_loss": 1.4890520693043465 + }, + { + "step": 1681, + "lr": 0.0001, + "sup_loss": 1.5029446680561438 + }, + { + "step": 1682, + "lr": 0.0001, + "sup_loss": 1.5472173324822431 + }, + { + "step": 1683, + "lr": 0.0001, + "sup_loss": 1.4702821940553288 + }, + { + "step": 1684, + "lr": 0.0001, + "sup_loss": 1.5582772229323976 + }, + { + "step": 1685, + "lr": 0.0001, + "sup_loss": 1.5141843667225285 + }, + { + "step": 1686, + "lr": 0.0001, + "sup_loss": 1.5069587023542834 + }, + { + "step": 1687, + "lr": 0.0001, + "sup_loss": 1.4993481079291866 + }, + { + "step": 1688, + "lr": 0.0001, + "sup_loss": 1.5236877515558036 + }, + { + "step": 1689, + "lr": 0.0001, + "sup_loss": 1.482728247792052 + }, + { + "step": 1690, + "lr": 0.0001, + "sup_loss": 1.5066147443340523 + }, + { + "step": 1691, + "lr": 0.0001, + "sup_loss": 1.5199840726518088 + }, + { + "step": 1692, + "lr": 0.0001, + "sup_loss": 1.5166131942078198 + }, + { + "step": 1693, + "lr": 0.0001, + "sup_loss": 1.5090159353445178 + }, + { + "step": 1694, + "lr": 0.0001, + "sup_loss": 1.5567879078399247 + }, + { + "step": 1695, + "lr": 0.0001, + "sup_loss": 1.5166663938732976 + }, + { + "step": 1696, + "lr": 0.0001, + "sup_loss": 1.5435607206957762 + }, + { + "step": 1697, + "lr": 0.0001, + "sup_loss": 1.5248312915612021 + }, + { + "step": 1698, + "lr": 0.0001, + "sup_loss": 1.5234049255246371 + }, + { + "step": 1699, + "lr": 0.0001, + "sup_loss": 1.5270521228590053 + }, + { + "step": 1700, + "lr": 0.0001, + "sup_loss": 1.5307370110397183, + "lyap1_mean": -10.525472640991211, + "lyap1_max": -10.16292667388916, + "lyap_spec_mean": [ + -10.525472640991211, + -11.110745429992676 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1701, + "lr": 0.0001, + "sup_loss": 1.481411383430075 + }, + { + "step": 1702, + "lr": 0.0001, + "sup_loss": 1.4993716992315493 + }, + { + "step": 1703, + "lr": 0.0001, + "sup_loss": 1.5397136814282606 + }, + { + "step": 1704, + "lr": 0.0001, + "sup_loss": 1.5197820070829378 + }, + { + "step": 1705, + "lr": 0.0001, + "sup_loss": 1.4659067097507272 + }, + { + "step": 1706, + "lr": 0.0001, + "sup_loss": 1.47606280125713 + }, + { + "step": 1707, + "lr": 0.0001, + "sup_loss": 1.5134314557479756 + }, + { + "step": 1708, + "lr": 0.0001, + "sup_loss": 1.4724650443288565 + }, + { + "step": 1709, + "lr": 0.0001, + "sup_loss": 1.491133652054465 + }, + { + "step": 1710, + "lr": 0.0001, + "sup_loss": 1.5507307923816782 + }, + { + "step": 1711, + "lr": 0.0001, + "sup_loss": 1.5234810886906243 + }, + { + "step": 1712, + "lr": 0.0001, + "sup_loss": 1.5003490941578155 + }, + { + "step": 1713, + "lr": 0.0001, + "sup_loss": 1.530479658014515 + }, + { + "step": 1714, + "lr": 0.0001, + "sup_loss": 1.4962610990075904 + }, + { + "step": 1715, + "lr": 0.0001, + "sup_loss": 1.5171798062498605 + }, + { + "step": 1716, + "lr": 0.0001, + "sup_loss": 1.5028523394166091 + }, + { + "step": 1717, + "lr": 0.0001, + "sup_loss": 1.49884965906956 + }, + { + "step": 1718, + "lr": 0.0001, + "sup_loss": 1.5359213880372653 + }, + { + "step": 1719, + "lr": 0.0001, + "sup_loss": 1.5507016629764787 + }, + { + "step": 1720, + "lr": 0.0001, + "sup_loss": 1.5171000832310666 + }, + { + "step": 1721, + "lr": 0.0001, + "sup_loss": 1.5264795681458354 + }, + { + "step": 1722, + "lr": 0.0001, + "sup_loss": 1.5340483371726588 + }, + { + "step": 1723, + "lr": 0.0001, + "sup_loss": 1.51408349521786 + }, + { + "step": 1724, + "lr": 0.0001, + "sup_loss": 1.4928249008794918 + }, + { + "step": 1725, + "lr": 0.0001, + "sup_loss": 1.512671326815062 + }, + { + "step": 1726, + "lr": 0.0001, + "sup_loss": 1.5209948903381836 + }, + { + "step": 1727, + "lr": 0.0001, + "sup_loss": 1.5264761722366604 + }, + { + "step": 1728, + "lr": 0.0001, + "sup_loss": 1.4896311008403842 + }, + { + "step": 1729, + "lr": 0.0001, + "sup_loss": 1.5134032369641919 + }, + { + "step": 1730, + "lr": 0.0001, + "sup_loss": 1.4997189970382823 + }, + { + "step": 1731, + "lr": 0.0001, + "sup_loss": 1.5297459986637532 + }, + { + "step": 1732, + "lr": 0.0001, + "sup_loss": 1.4929931881971388 + }, + { + "step": 1733, + "lr": 0.0001, + "sup_loss": 1.495912590422481 + }, + { + "step": 1734, + "lr": 0.0001, + "sup_loss": 1.507206131358185 + }, + { + "step": 1735, + "lr": 0.0001, + "sup_loss": 1.5404803143698969 + }, + { + "step": 1736, + "lr": 0.0001, + "sup_loss": 1.5133734109981594 + }, + { + "step": 1737, + "lr": 0.0001, + "sup_loss": 1.5104855219938502 + }, + { + "step": 1738, + "lr": 0.0001, + "sup_loss": 1.5059634577181915 + }, + { + "step": 1739, + "lr": 0.0001, + "sup_loss": 1.5301966495812462 + }, + { + "step": 1740, + "lr": 0.0001, + "sup_loss": 1.5061798756951152 + }, + { + "step": 1741, + "lr": 0.0001, + "sup_loss": 1.4384166515654637 + }, + { + "step": 1742, + "lr": 0.0001, + "sup_loss": 1.5002527729638158 + }, + { + "step": 1743, + "lr": 0.0001, + "sup_loss": 1.5068285385684124 + }, + { + "step": 1744, + "lr": 0.0001, + "sup_loss": 1.4903059034077626 + }, + { + "step": 1745, + "lr": 0.0001, + "sup_loss": 1.522711962523792 + }, + { + "step": 1746, + "lr": 0.0001, + "sup_loss": 1.5162339454758005 + }, + { + "step": 1747, + "lr": 0.0001, + "sup_loss": 1.5108600252088566 + }, + { + "step": 1748, + "lr": 0.0001, + "sup_loss": 1.5157122727884602 + }, + { + "step": 1749, + "lr": 0.0001, + "sup_loss": 1.5248520508575514 + }, + { + "step": 1750, + "lr": 0.0001, + "sup_loss": 1.5055940499245726, + "lyap1_mean": -10.642162322998047, + "lyap1_max": -10.365160942077637, + "lyap_spec_mean": [ + -10.642162322998047, + -11.194787979125977 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1751, + "lr": 0.0001, + "sup_loss": 1.5232028526274362 + }, + { + "step": 1752, + "lr": 0.0001, + "sup_loss": 1.527927418133434 + }, + { + "step": 1753, + "lr": 0.0001, + "sup_loss": 1.5240177082015276 + }, + { + "step": 1754, + "lr": 0.0001, + "sup_loss": 1.4902081227064985 + }, + { + "step": 1755, + "lr": 0.0001, + "sup_loss": 1.5041870584693129 + }, + { + "step": 1756, + "lr": 0.0001, + "sup_loss": 1.5127901965203112 + }, + { + "step": 1757, + "lr": 0.0001, + "sup_loss": 1.506023636151414 + }, + { + "step": 1758, + "lr": 0.0001, + "sup_loss": 1.5399555616708003 + }, + { + "step": 1759, + "lr": 0.0001, + "sup_loss": 1.492647450362024 + }, + { + "step": 1760, + "lr": 0.0001, + "sup_loss": 1.4786864843763954 + }, + { + "step": 1761, + "lr": 0.0001, + "sup_loss": 1.4934734160208394 + }, + { + "step": 1762, + "lr": 0.0001, + "sup_loss": 1.5202877663628083 + }, + { + "step": 1763, + "lr": 0.0001, + "sup_loss": 1.5000071131229133 + }, + { + "step": 1764, + "lr": 0.0001, + "sup_loss": 1.5269099803032982 + }, + { + "step": 1765, + "lr": 0.0001, + "sup_loss": 1.5034782882032947 + }, + { + "step": 1766, + "lr": 0.0001, + "sup_loss": 1.513331589448419 + }, + { + "step": 1767, + "lr": 0.0001, + "sup_loss": 1.514107044044326 + }, + { + "step": 1768, + "lr": 0.0001, + "sup_loss": 1.506593683133455 + }, + { + "step": 1769, + "lr": 0.0001, + "sup_loss": 1.48604021744496 + }, + { + "step": 1770, + "lr": 0.0001, + "sup_loss": 1.51098057131189 + }, + { + "step": 1771, + "lr": 0.0001, + "sup_loss": 1.5044059736067399 + }, + { + "step": 1772, + "lr": 0.0001, + "sup_loss": 1.530470706973546 + }, + { + "step": 1773, + "lr": 0.0001, + "sup_loss": 1.512065829210465 + }, + { + "step": 1774, + "lr": 0.0001, + "sup_loss": 1.4960605515563545 + }, + { + "step": 1775, + "lr": 0.0001, + "sup_loss": 1.5135602708994254 + }, + { + "step": 1776, + "lr": 0.0001, + "sup_loss": 1.5199000285891948 + }, + { + "step": 1777, + "lr": 0.0001, + "sup_loss": 1.5123500834690387 + }, + { + "step": 1778, + "lr": 0.0001, + "sup_loss": 1.5304107526173578 + }, + { + "step": 1779, + "lr": 0.0001, + "sup_loss": 1.513602516636453 + }, + { + "step": 1780, + "lr": 0.0001, + "sup_loss": 1.516562657667677 + }, + { + "step": 1781, + "lr": 0.0001, + "sup_loss": 1.526798659468714 + }, + { + "step": 1782, + "lr": 0.0001, + "sup_loss": 1.499950138798777 + }, + { + "step": 1783, + "lr": 0.0001, + "sup_loss": 1.4797331142771326 + }, + { + "step": 1784, + "lr": 0.0001, + "sup_loss": 1.5132061108372878 + }, + { + "step": 1785, + "lr": 0.0001, + "sup_loss": 1.5399208614874982 + }, + { + "step": 1786, + "lr": 0.0001, + "sup_loss": 1.5231493399402467 + }, + { + "step": 1787, + "lr": 0.0001, + "sup_loss": 1.5207748463147464 + }, + { + "step": 1788, + "lr": 0.0001, + "sup_loss": 1.4724264007482062 + }, + { + "step": 1789, + "lr": 0.0001, + "sup_loss": 1.459132209067092 + }, + { + "step": 1790, + "lr": 0.0001, + "sup_loss": 1.502888624204677 + }, + { + "step": 1791, + "lr": 0.0001, + "sup_loss": 1.5096714376100688 + }, + { + "step": 1792, + "lr": 0.0001, + "sup_loss": 1.48941207910585 + }, + { + "step": 1793, + "lr": 0.0001, + "sup_loss": 1.533063344618789 + }, + { + "step": 1794, + "lr": 0.0001, + "sup_loss": 1.5301017276695466 + }, + { + "step": 1795, + "lr": 0.0001, + "sup_loss": 1.5332066525461543 + }, + { + "step": 1796, + "lr": 0.0001, + "sup_loss": 1.5099248148260427 + }, + { + "step": 1797, + "lr": 0.0001, + "sup_loss": 1.509701103557131 + }, + { + "step": 1798, + "lr": 0.0001, + "sup_loss": 1.5019860034082702 + }, + { + "step": 1799, + "lr": 0.0001, + "sup_loss": 1.4866764921554307 + }, + { + "step": 1800, + "lr": 0.0001, + "sup_loss": 1.5271933121149641, + "lyap1_mean": -11.182738304138184, + "lyap1_max": -10.787989616394043, + "lyap_spec_mean": [ + -11.1827392578125, + -11.388103485107422 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1801, + "lr": 0.0001, + "sup_loss": 1.4888855749801202 + }, + { + "step": 1802, + "lr": 0.0001, + "sup_loss": 1.478579532533178 + }, + { + "step": 1803, + "lr": 0.0001, + "sup_loss": 1.5446485785599717 + }, + { + "step": 1804, + "lr": 0.0001, + "sup_loss": 1.5248110241117385 + }, + { + "step": 1805, + "lr": 0.0001, + "sup_loss": 1.5107811671296754 + }, + { + "step": 1806, + "lr": 0.0001, + "sup_loss": 1.4790010443508 + }, + { + "step": 1807, + "lr": 0.0001, + "sup_loss": 1.5230718600002535 + }, + { + "step": 1808, + "lr": 0.0001, + "sup_loss": 1.5162631718277348 + }, + { + "step": 1809, + "lr": 0.0001, + "sup_loss": 1.489110688129902 + }, + { + "step": 1810, + "lr": 0.0001, + "sup_loss": 1.5405423380264127 + }, + { + "step": 1811, + "lr": 0.0001, + "sup_loss": 1.5200435045614253 + }, + { + "step": 1812, + "lr": 0.0001, + "sup_loss": 1.5097177210593955 + }, + { + "step": 1813, + "lr": 0.0001, + "sup_loss": 1.5240169755657054 + }, + { + "step": 1814, + "lr": 0.0001, + "sup_loss": 1.5306888213781211 + }, + { + "step": 1815, + "lr": 0.0001, + "sup_loss": 1.5347460042879673 + }, + { + "step": 1816, + "lr": 0.0001, + "sup_loss": 1.5326829836017952 + }, + { + "step": 1817, + "lr": 0.0001, + "sup_loss": 1.5023287234629488 + }, + { + "step": 1818, + "lr": 0.0001, + "sup_loss": 1.503224369753803 + }, + { + "step": 1819, + "lr": 0.0001, + "sup_loss": 1.5164595350328995 + }, + { + "step": 1820, + "lr": 0.0001, + "sup_loss": 1.539942872882069 + }, + { + "step": 1821, + "lr": 0.0001, + "sup_loss": 1.516827712886876 + }, + { + "step": 1822, + "lr": 0.0001, + "sup_loss": 1.4724214639607673 + }, + { + "step": 1823, + "lr": 0.0001, + "sup_loss": 1.5337824751431672 + }, + { + "step": 1824, + "lr": 0.0001, + "sup_loss": 1.4993437440930333 + }, + { + "step": 1825, + "lr": 0.0001, + "sup_loss": 1.5131270450083842 + }, + { + "step": 1826, + "lr": 0.0001, + "sup_loss": 1.5373142038498564 + }, + { + "step": 1827, + "lr": 0.0001, + "sup_loss": 1.502076077820181 + }, + { + "step": 1828, + "lr": 0.0001, + "sup_loss": 1.51116839613309 + }, + { + "step": 1829, + "lr": 0.0001, + "sup_loss": 1.5059921299991965 + }, + { + "step": 1830, + "lr": 0.0001, + "sup_loss": 1.5194548261752712 + }, + { + "step": 1831, + "lr": 0.0001, + "sup_loss": 1.509558087178071 + }, + { + "step": 1832, + "lr": 0.0001, + "sup_loss": 1.5166805734092024 + }, + { + "step": 1833, + "lr": 0.0001, + "sup_loss": 1.50386782398312 + }, + { + "step": 1834, + "lr": 0.0001, + "sup_loss": 1.482696034530058 + }, + { + "step": 1835, + "lr": 0.0001, + "sup_loss": 1.5205362815841295 + }, + { + "step": 1836, + "lr": 0.0001, + "sup_loss": 1.50954779906111 + }, + { + "step": 1837, + "lr": 0.0001, + "sup_loss": 1.506284391055561 + }, + { + "step": 1838, + "lr": 0.0001, + "sup_loss": 1.543451000515031 + }, + { + "step": 1839, + "lr": 0.0001, + "sup_loss": 1.5402650700699991 + }, + { + "step": 1840, + "lr": 0.0001, + "sup_loss": 1.5406849103958773 + }, + { + "step": 1841, + "lr": 0.0001, + "sup_loss": 1.5266263474089212 + }, + { + "step": 1842, + "lr": 0.0001, + "sup_loss": 1.5053457552457143 + }, + { + "step": 1843, + "lr": 0.0001, + "sup_loss": 1.5163531591427457 + }, + { + "step": 1844, + "lr": 0.0001, + "sup_loss": 1.496208224922569 + }, + { + "step": 1845, + "lr": 0.0001, + "sup_loss": 1.523695638894029 + }, + { + "step": 1846, + "lr": 0.0001, + "sup_loss": 1.5161531894694695 + }, + { + "step": 1847, + "lr": 0.0001, + "sup_loss": 1.4943990218298056 + }, + { + "step": 1848, + "lr": 0.0001, + "sup_loss": 1.5025525349743836 + }, + { + "step": 1849, + "lr": 0.0001, + "sup_loss": 1.546597616565546 + }, + { + "step": 1850, + "lr": 0.0001, + "sup_loss": 1.4927943683642584, + "lyap1_mean": -11.350260734558105, + "lyap1_max": -11.024365425109863, + "lyap_spec_mean": [ + -11.350261688232422, + -11.566762924194336 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1851, + "lr": 0.0001, + "sup_loss": 1.4828801438804151 + }, + { + "step": 1852, + "lr": 0.0001, + "sup_loss": 1.5124738808101315 + }, + { + "step": 1853, + "lr": 0.0001, + "sup_loss": 1.5068149089224765 + }, + { + "step": 1854, + "lr": 0.0001, + "sup_loss": 1.5268369979023186 + }, + { + "step": 1855, + "lr": 0.0001, + "sup_loss": 1.4935662803043175 + }, + { + "step": 1856, + "lr": 0.0001, + "sup_loss": 1.527032508277338 + }, + { + "step": 1857, + "lr": 0.0001, + "sup_loss": 1.5162206052201388 + }, + { + "step": 1858, + "lr": 0.0001, + "sup_loss": 1.5299600046671504 + }, + { + "step": 1859, + "lr": 0.0001, + "sup_loss": 1.464968998460744 + }, + { + "step": 1860, + "lr": 0.0001, + "sup_loss": 1.5149053810257092 + }, + { + "step": 1861, + "lr": 0.0001, + "sup_loss": 1.4902782254370532 + }, + { + "step": 1862, + "lr": 0.0001, + "sup_loss": 1.5205711725885287 + }, + { + "step": 1863, + "lr": 0.0001, + "sup_loss": 1.4899912526695365 + }, + { + "step": 1864, + "lr": 0.0001, + "sup_loss": 1.5038157356327915 + }, + { + "step": 1865, + "lr": 0.0001, + "sup_loss": 1.522788720877462 + }, + { + "step": 1866, + "lr": 0.0001, + "sup_loss": 1.527266835745125 + }, + { + "step": 1867, + "lr": 0.0001, + "sup_loss": 1.5239887348576355 + }, + { + "step": 1868, + "lr": 0.0001, + "sup_loss": 1.4923718874642167 + }, + { + "step": 1869, + "lr": 0.0001, + "sup_loss": 1.5511040104049412 + }, + { + "step": 1870, + "lr": 0.0001, + "sup_loss": 1.4962683091729334 + }, + { + "step": 1871, + "lr": 0.0001, + "sup_loss": 1.4630238294653635 + }, + { + "step": 1872, + "lr": 0.0001, + "sup_loss": 1.4961777490987664 + }, + { + "step": 1873, + "lr": 0.0001, + "sup_loss": 1.5026580888123175 + }, + { + "step": 1874, + "lr": 0.0001, + "sup_loss": 1.5138371771004566 + }, + { + "step": 1875, + "lr": 0.0001, + "sup_loss": 1.5022063200582185 + }, + { + "step": 1876, + "lr": 0.0001, + "sup_loss": 1.4754897976379695 + }, + { + "step": 1877, + "lr": 0.0001, + "sup_loss": 1.516692608842145 + }, + { + "step": 1878, + "lr": 0.0001, + "sup_loss": 1.5164441531889494 + }, + { + "step": 1879, + "lr": 0.0001, + "sup_loss": 1.5545073471559936 + }, + { + "step": 1880, + "lr": 0.0001, + "sup_loss": 1.5224709981289424 + }, + { + "step": 1881, + "lr": 0.0001, + "sup_loss": 1.5298205557960358 + }, + { + "step": 1882, + "lr": 0.0001, + "sup_loss": 1.5132585890649994 + }, + { + "step": 1883, + "lr": 0.0001, + "sup_loss": 1.5307324769740507 + }, + { + "step": 1884, + "lr": 0.0001, + "sup_loss": 1.5160812332787434 + }, + { + "step": 1885, + "lr": 0.0001, + "sup_loss": 1.5263274864135603 + }, + { + "step": 1886, + "lr": 0.0001, + "sup_loss": 1.5235706895313643 + }, + { + "step": 1887, + "lr": 0.0001, + "sup_loss": 1.4866203655425223 + }, + { + "step": 1888, + "lr": 0.0001, + "sup_loss": 1.5296680983709832 + }, + { + "step": 1889, + "lr": 0.0001, + "sup_loss": 1.5165410693080534 + }, + { + "step": 1890, + "lr": 0.0001, + "sup_loss": 1.4929883596561704 + }, + { + "step": 1891, + "lr": 0.0001, + "sup_loss": 1.5200822403182412 + }, + { + "step": 1892, + "lr": 0.0001, + "sup_loss": 1.5023364976665654 + }, + { + "step": 1893, + "lr": 0.0001, + "sup_loss": 1.5064116768877123 + }, + { + "step": 1894, + "lr": 0.0001, + "sup_loss": 1.5158950347137436 + }, + { + "step": 1895, + "lr": 0.0001, + "sup_loss": 1.5097240263724525 + }, + { + "step": 1896, + "lr": 0.0001, + "sup_loss": 1.5168045584040195 + }, + { + "step": 1897, + "lr": 0.0001, + "sup_loss": 1.4991592560824534 + }, + { + "step": 1898, + "lr": 0.0001, + "sup_loss": 1.5065187714430617 + }, + { + "step": 1899, + "lr": 0.0001, + "sup_loss": 1.5435677092028117 + }, + { + "step": 1900, + "lr": 0.0001, + "sup_loss": 1.5243176205936446, + "lyap1_mean": -11.329150199890137, + "lyap1_max": -10.887066841125488, + "lyap_spec_mean": [ + -11.329150199890137, + -11.633506774902344 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1901, + "lr": 0.0001, + "sup_loss": 1.5408980180501075 + }, + { + "step": 1902, + "lr": 0.0001, + "sup_loss": 1.529878184629819 + }, + { + "step": 1903, + "lr": 0.0001, + "sup_loss": 1.4824830222728582 + }, + { + "step": 1904, + "lr": 0.0001, + "sup_loss": 1.5394627202323563 + }, + { + "step": 1905, + "lr": 0.0001, + "sup_loss": 1.52067575790002 + }, + { + "step": 1906, + "lr": 0.0001, + "sup_loss": 1.530581512392956 + }, + { + "step": 1907, + "lr": 0.0001, + "sup_loss": 1.5131239402551098 + }, + { + "step": 1908, + "lr": 0.0001, + "sup_loss": 1.5158721004392381 + }, + { + "step": 1909, + "lr": 0.0001, + "sup_loss": 1.5195020153417018 + }, + { + "step": 1910, + "lr": 0.0001, + "sup_loss": 1.5194494836761232 + }, + { + "step": 1911, + "lr": 0.0001, + "sup_loss": 1.5128595800623839 + }, + { + "step": 1912, + "lr": 0.0001, + "sup_loss": 1.4894953655913588 + }, + { + "step": 1913, + "lr": 0.0001, + "sup_loss": 1.5168121119978708 + }, + { + "step": 1914, + "lr": 0.0001, + "sup_loss": 1.4947312060515185 + }, + { + "step": 1915, + "lr": 0.0001, + "sup_loss": 1.5265571552433554 + }, + { + "step": 1916, + "lr": 0.0001, + "sup_loss": 1.5244353534672161 + }, + { + "step": 1917, + "lr": 0.0001, + "sup_loss": 1.5132042302801905 + }, + { + "step": 1918, + "lr": 0.0001, + "sup_loss": 1.5193007845851727 + }, + { + "step": 1919, + "lr": 0.0001, + "sup_loss": 1.547049200274394 + }, + { + "step": 1920, + "lr": 0.0001, + "sup_loss": 1.5061301152468203 + }, + { + "step": 1921, + "lr": 0.0001, + "sup_loss": 1.5026853099920103 + }, + { + "step": 1922, + "lr": 0.0001, + "sup_loss": 1.516391646557362 + }, + { + "step": 1923, + "lr": 0.0001, + "sup_loss": 1.5065272910710727 + }, + { + "step": 1924, + "lr": 0.0001, + "sup_loss": 1.462061181154183 + }, + { + "step": 1925, + "lr": 0.0001, + "sup_loss": 1.5200037139388816 + }, + { + "step": 1926, + "lr": 0.0001, + "sup_loss": 1.5231107866892761 + }, + { + "step": 1927, + "lr": 0.0001, + "sup_loss": 1.5163330448538517 + }, + { + "step": 1928, + "lr": 0.0001, + "sup_loss": 1.5135069441686293 + }, + { + "step": 1929, + "lr": 0.0001, + "sup_loss": 1.5063628330559633 + }, + { + "step": 1930, + "lr": 0.0001, + "sup_loss": 1.536394974481492 + }, + { + "step": 1931, + "lr": 0.0001, + "sup_loss": 1.4784632383336695 + }, + { + "step": 1932, + "lr": 0.0001, + "sup_loss": 1.5197840860348282 + }, + { + "step": 1933, + "lr": 0.0001, + "sup_loss": 1.479212370839797 + }, + { + "step": 1934, + "lr": 0.0001, + "sup_loss": 1.4956279077176617 + }, + { + "step": 1935, + "lr": 0.0001, + "sup_loss": 1.5232151279036332 + }, + { + "step": 1936, + "lr": 0.0001, + "sup_loss": 1.5199022077670774 + }, + { + "step": 1937, + "lr": 0.0001, + "sup_loss": 1.4958386441305753 + }, + { + "step": 1938, + "lr": 0.0001, + "sup_loss": 1.519926480777136 + }, + { + "step": 1939, + "lr": 0.0001, + "sup_loss": 1.4759535430879243 + }, + { + "step": 1940, + "lr": 0.0001, + "sup_loss": 1.4960990422044143 + }, + { + "step": 1941, + "lr": 0.0001, + "sup_loss": 1.5129458140093381 + }, + { + "step": 1942, + "lr": 0.0001, + "sup_loss": 1.5090788754341726 + }, + { + "step": 1943, + "lr": 0.0001, + "sup_loss": 1.5263751149874247 + }, + { + "step": 1944, + "lr": 0.0001, + "sup_loss": 1.5031065913327952 + }, + { + "step": 1945, + "lr": 0.0001, + "sup_loss": 1.50529645187412 + }, + { + "step": 1946, + "lr": 0.0001, + "sup_loss": 1.5143349929800334 + }, + { + "step": 1947, + "lr": 0.0001, + "sup_loss": 1.5128904450645235 + }, + { + "step": 1948, + "lr": 0.0001, + "sup_loss": 1.510385294312491 + }, + { + "step": 1949, + "lr": 0.0001, + "sup_loss": 1.5233833708566176 + }, + { + "step": 1950, + "lr": 0.0001, + "sup_loss": 1.5165996918089137, + "lyap1_mean": -11.296674728393555, + "lyap1_max": -10.911211967468262, + "lyap_spec_mean": [ + -11.296675682067871, + -11.475123405456543 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 1951, + "lr": 0.0001, + "sup_loss": 1.5126838632293205 + }, + { + "step": 1952, + "lr": 0.0001, + "sup_loss": 1.5061037745799022 + }, + { + "step": 1953, + "lr": 0.0001, + "sup_loss": 1.529811012647908 + }, + { + "step": 1954, + "lr": 0.0001, + "sup_loss": 1.5027730328589006 + }, + { + "step": 1955, + "lr": 0.0001, + "sup_loss": 1.502647503741002 + }, + { + "step": 1956, + "lr": 0.0001, + "sup_loss": 1.4825297606212549 + }, + { + "step": 1957, + "lr": 0.0001, + "sup_loss": 1.5367913166161384 + }, + { + "step": 1958, + "lr": 0.0001, + "sup_loss": 1.5270714134060588 + }, + { + "step": 1959, + "lr": 0.0001, + "sup_loss": 1.5056502383506105 + }, + { + "step": 1960, + "lr": 0.0001, + "sup_loss": 1.5133130284114382 + }, + { + "step": 1961, + "lr": 0.0001, + "sup_loss": 1.5062239482447535 + }, + { + "step": 1962, + "lr": 0.0001, + "sup_loss": 1.506231833035333 + }, + { + "step": 1963, + "lr": 0.0001, + "sup_loss": 1.4751764540746704 + }, + { + "step": 1964, + "lr": 0.0001, + "sup_loss": 1.557161778325136 + }, + { + "step": 1965, + "lr": 0.0001, + "sup_loss": 1.4721003170641185 + }, + { + "step": 1966, + "lr": 0.0001, + "sup_loss": 1.550486393626624 + }, + { + "step": 1967, + "lr": 0.0001, + "sup_loss": 1.5232885109775507 + }, + { + "step": 1968, + "lr": 0.0001, + "sup_loss": 1.506768561863416 + }, + { + "step": 1969, + "lr": 0.0001, + "sup_loss": 1.5435294897233076 + }, + { + "step": 1970, + "lr": 0.0001, + "sup_loss": 1.5366586929120913 + }, + { + "step": 1971, + "lr": 0.0001, + "sup_loss": 1.5470222351381353 + }, + { + "step": 1972, + "lr": 0.0001, + "sup_loss": 1.5069680530003307 + }, + { + "step": 1973, + "lr": 0.0001, + "sup_loss": 1.4895721957430499 + }, + { + "step": 1974, + "lr": 0.0001, + "sup_loss": 1.526557934651818 + }, + { + "step": 1975, + "lr": 0.0001, + "sup_loss": 1.5205668347845713 + }, + { + "step": 1976, + "lr": 0.0001, + "sup_loss": 1.5409084967802709 + }, + { + "step": 1977, + "lr": 0.0001, + "sup_loss": 1.560826931225716 + }, + { + "step": 1978, + "lr": 0.0001, + "sup_loss": 1.517724260399073 + }, + { + "step": 1979, + "lr": 0.0001, + "sup_loss": 1.5298820827209456 + }, + { + "step": 1980, + "lr": 0.0001, + "sup_loss": 1.5236799517031445 + }, + { + "step": 1981, + "lr": 0.0001, + "sup_loss": 1.4856180622305646 + }, + { + "step": 1982, + "lr": 0.0001, + "sup_loss": 1.5404660162851582 + }, + { + "step": 1983, + "lr": 0.0001, + "sup_loss": 1.466133648262751 + }, + { + "step": 1984, + "lr": 0.0001, + "sup_loss": 1.5409720562685154 + }, + { + "step": 1985, + "lr": 0.0001, + "sup_loss": 1.5133643869407623 + }, + { + "step": 1986, + "lr": 0.0001, + "sup_loss": 1.5198814068188067 + }, + { + "step": 1987, + "lr": 0.0001, + "sup_loss": 1.512776128900203 + }, + { + "step": 1988, + "lr": 0.0001, + "sup_loss": 1.5155689293823582 + }, + { + "step": 1989, + "lr": 0.0001, + "sup_loss": 1.5197537385478508 + }, + { + "step": 1990, + "lr": 0.0001, + "sup_loss": 1.49988733167699 + }, + { + "step": 1991, + "lr": 0.0001, + "sup_loss": 1.5375862499993465 + }, + { + "step": 1992, + "lr": 0.0001, + "sup_loss": 1.5197949293069368 + }, + { + "step": 1993, + "lr": 0.0001, + "sup_loss": 1.5076429724249754 + }, + { + "step": 1994, + "lr": 0.0001, + "sup_loss": 1.5168911869161323 + }, + { + "step": 1995, + "lr": 0.0001, + "sup_loss": 1.5204201662365537 + }, + { + "step": 1996, + "lr": 0.0001, + "sup_loss": 1.5232493152488875 + }, + { + "step": 1997, + "lr": 0.0001, + "sup_loss": 1.492675341711571 + }, + { + "step": 1998, + "lr": 0.0001, + "sup_loss": 1.4855018446949795 + }, + { + "step": 1999, + "lr": 0.0001, + "sup_loss": 1.4930537951853173 + }, + { + "step": 2000, + "lr": 0.0001, + "sup_loss": 1.4866397791286017, + "lyap1_mean": -11.322970390319824, + "lyap1_max": -10.890480041503906, + "lyap_spec_mean": [ + -11.322970390319824, + -11.490907669067383 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2001, + "lr": 0.0001, + "sup_loss": 1.4960011935116655 + }, + { + "step": 2002, + "lr": 0.0001, + "sup_loss": 1.5843898969463188 + }, + { + "step": 2003, + "lr": 0.0001, + "sup_loss": 1.5400172172642808 + }, + { + "step": 2004, + "lr": 0.0001, + "sup_loss": 1.5058823991673764 + }, + { + "step": 2005, + "lr": 0.0001, + "sup_loss": 1.4996476350930164 + }, + { + "step": 2006, + "lr": 0.0001, + "sup_loss": 1.5330513299854607 + }, + { + "step": 2007, + "lr": 0.0001, + "sup_loss": 1.5197170390370436 + }, + { + "step": 2008, + "lr": 0.0001, + "sup_loss": 1.5231608396776257 + }, + { + "step": 2009, + "lr": 0.0001, + "sup_loss": 1.5230797554356694 + }, + { + "step": 2010, + "lr": 0.0001, + "sup_loss": 1.4826035577308472 + }, + { + "step": 2011, + "lr": 0.0001, + "sup_loss": 1.5027263278312901 + }, + { + "step": 2012, + "lr": 0.0001, + "sup_loss": 1.5032449905013745 + }, + { + "step": 2013, + "lr": 0.0001, + "sup_loss": 1.5117349264123652 + }, + { + "step": 2014, + "lr": 0.0001, + "sup_loss": 1.4512984583248767 + }, + { + "step": 2015, + "lr": 0.0001, + "sup_loss": 1.493403601211862 + }, + { + "step": 2016, + "lr": 0.0001, + "sup_loss": 1.5131610372813793 + }, + { + "step": 2017, + "lr": 0.0001, + "sup_loss": 1.5027806580185081 + }, + { + "step": 2018, + "lr": 0.0001, + "sup_loss": 1.5096814022771459 + }, + { + "step": 2019, + "lr": 0.0001, + "sup_loss": 1.4916280041198307 + }, + { + "step": 2020, + "lr": 0.0001, + "sup_loss": 1.5133228461003012 + }, + { + "step": 2021, + "lr": 0.0001, + "sup_loss": 1.5308520424091372 + }, + { + "step": 2022, + "lr": 0.0001, + "sup_loss": 1.4930235056443313 + }, + { + "step": 2023, + "lr": 0.0001, + "sup_loss": 1.5040111716455373 + }, + { + "step": 2024, + "lr": 0.0001, + "sup_loss": 1.5097771840249492 + }, + { + "step": 2025, + "lr": 0.0001, + "sup_loss": 1.5364915175644998 + }, + { + "step": 2026, + "lr": 0.0001, + "sup_loss": 1.5228221599994014 + }, + { + "step": 2027, + "lr": 0.0001, + "sup_loss": 1.509705522162977 + }, + { + "step": 2028, + "lr": 0.0001, + "sup_loss": 1.5024930349738628 + }, + { + "step": 2029, + "lr": 0.0001, + "sup_loss": 1.4925471535338206 + }, + { + "step": 2030, + "lr": 0.0001, + "sup_loss": 1.5140509677276164 + }, + { + "step": 2031, + "lr": 0.0001, + "sup_loss": 1.5034397305307876 + }, + { + "step": 2032, + "lr": 0.0001, + "sup_loss": 1.4896844492970625 + }, + { + "step": 2033, + "lr": 0.0001, + "sup_loss": 1.5167836598091877 + }, + { + "step": 2034, + "lr": 0.0001, + "sup_loss": 1.5272673332679583 + }, + { + "step": 2035, + "lr": 0.0001, + "sup_loss": 1.5002166095341907 + }, + { + "step": 2036, + "lr": 0.0001, + "sup_loss": 1.4751988757543943 + }, + { + "step": 2037, + "lr": 0.0001, + "sup_loss": 1.5231128219469563 + }, + { + "step": 2038, + "lr": 0.0001, + "sup_loss": 1.5199568907380896 + }, + { + "step": 2039, + "lr": 0.0001, + "sup_loss": 1.5099439342899725 + }, + { + "step": 2040, + "lr": 0.0001, + "sup_loss": 1.4995330269919516 + }, + { + "step": 2041, + "lr": 0.0001, + "sup_loss": 1.5130296305520154 + }, + { + "step": 2042, + "lr": 0.0001, + "sup_loss": 1.5034688136824554 + }, + { + "step": 2043, + "lr": 0.0001, + "sup_loss": 1.5333496004314011 + }, + { + "step": 2044, + "lr": 0.0001, + "sup_loss": 1.499723974249949 + }, + { + "step": 2045, + "lr": 0.0001, + "sup_loss": 1.5234534027858746 + }, + { + "step": 2046, + "lr": 0.0001, + "sup_loss": 1.5066064727355812 + }, + { + "step": 2047, + "lr": 0.0001, + "sup_loss": 1.5031497824016686 + }, + { + "step": 2048, + "lr": 0.0001, + "sup_loss": 1.507035281783747 + }, + { + "step": 2049, + "lr": 0.0001, + "sup_loss": 1.479506332049932 + }, + { + "step": 2050, + "lr": 0.0001, + "sup_loss": 1.5196813315753948, + "lyap1_mean": -11.021892547607422, + "lyap1_max": -10.215132713317871, + "lyap_spec_mean": [ + -11.021892547607422, + -11.340229034423828 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2051, + "lr": 0.0001, + "sup_loss": 1.4920647126644309 + }, + { + "step": 2052, + "lr": 0.0001, + "sup_loss": 1.513333230788504 + }, + { + "step": 2053, + "lr": 0.0001, + "sup_loss": 1.5039675699097106 + }, + { + "step": 2054, + "lr": 0.0001, + "sup_loss": 1.540374376614778 + }, + { + "step": 2055, + "lr": 0.0001, + "sup_loss": 1.5159352534604937 + }, + { + "step": 2056, + "lr": 0.0001, + "sup_loss": 1.5264475662182766 + }, + { + "step": 2057, + "lr": 0.0001, + "sup_loss": 1.4619770340836666 + }, + { + "step": 2058, + "lr": 0.0001, + "sup_loss": 1.5067464078516937 + }, + { + "step": 2059, + "lr": 0.0001, + "sup_loss": 1.5129929244247184 + }, + { + "step": 2060, + "lr": 0.0001, + "sup_loss": 1.5197639439003665 + }, + { + "step": 2061, + "lr": 0.0001, + "sup_loss": 1.506922128746094 + }, + { + "step": 2062, + "lr": 0.0001, + "sup_loss": 1.492705828192339 + }, + { + "step": 2063, + "lr": 0.0001, + "sup_loss": 1.5269641201723787 + }, + { + "step": 2064, + "lr": 0.0001, + "sup_loss": 1.513383464515944 + }, + { + "step": 2065, + "lr": 0.0001, + "sup_loss": 1.513251808385605 + }, + { + "step": 2066, + "lr": 0.0001, + "sup_loss": 1.498837931328409 + }, + { + "step": 2067, + "lr": 0.0001, + "sup_loss": 1.5227745086902698 + }, + { + "step": 2068, + "lr": 0.0001, + "sup_loss": 1.5161886765457278 + }, + { + "step": 2069, + "lr": 0.0001, + "sup_loss": 1.506510200705621 + }, + { + "step": 2070, + "lr": 0.0001, + "sup_loss": 1.5098678143301074 + }, + { + "step": 2071, + "lr": 0.0001, + "sup_loss": 1.52321140631544 + }, + { + "step": 2072, + "lr": 0.0001, + "sup_loss": 1.493114373140738 + }, + { + "step": 2073, + "lr": 0.0001, + "sup_loss": 1.5333833581302163 + }, + { + "step": 2074, + "lr": 0.0001, + "sup_loss": 1.519020048385059 + }, + { + "step": 2075, + "lr": 0.0001, + "sup_loss": 1.490348879155686 + }, + { + "step": 2076, + "lr": 0.0001, + "sup_loss": 1.5335794470051423 + }, + { + "step": 2077, + "lr": 0.0001, + "sup_loss": 1.4687414211249499 + }, + { + "step": 2078, + "lr": 0.0001, + "sup_loss": 1.4964815272097285 + }, + { + "step": 2079, + "lr": 0.0001, + "sup_loss": 1.5336186923685489 + }, + { + "step": 2080, + "lr": 0.0001, + "sup_loss": 1.577620624229406 + }, + { + "step": 2081, + "lr": 0.0001, + "sup_loss": 1.506977744695885 + }, + { + "step": 2082, + "lr": 0.0001, + "sup_loss": 1.516647250524058 + }, + { + "step": 2083, + "lr": 0.0001, + "sup_loss": 1.498703258764262 + }, + { + "step": 2084, + "lr": 0.0001, + "sup_loss": 1.5468984456486832 + }, + { + "step": 2085, + "lr": 0.0001, + "sup_loss": 1.4718660657663998 + }, + { + "step": 2086, + "lr": 0.0001, + "sup_loss": 1.4621467018003211 + }, + { + "step": 2087, + "lr": 0.0001, + "sup_loss": 1.512751069290027 + }, + { + "step": 2088, + "lr": 0.0001, + "sup_loss": 1.4890318318290003 + }, + { + "step": 2089, + "lr": 0.0001, + "sup_loss": 1.5017267979385522 + }, + { + "step": 2090, + "lr": 0.0001, + "sup_loss": 1.5164450406288357 + }, + { + "step": 2091, + "lr": 0.0001, + "sup_loss": 1.5066016752490405 + }, + { + "step": 2092, + "lr": 0.0001, + "sup_loss": 1.5234225425197194 + }, + { + "step": 2093, + "lr": 0.0001, + "sup_loss": 1.4996083852673308 + }, + { + "step": 2094, + "lr": 0.0001, + "sup_loss": 1.5296477495323866 + }, + { + "step": 2095, + "lr": 0.0001, + "sup_loss": 1.495720962494964 + }, + { + "step": 2096, + "lr": 0.0001, + "sup_loss": 1.5326038749583273 + }, + { + "step": 2097, + "lr": 0.0001, + "sup_loss": 1.5496362548317915 + }, + { + "step": 2098, + "lr": 0.0001, + "sup_loss": 1.5305920520449736 + }, + { + "step": 2099, + "lr": 0.0001, + "sup_loss": 1.5169324151341181 + }, + { + "step": 2100, + "lr": 0.0001, + "sup_loss": 1.5131090280170088, + "lyap1_mean": -10.525592803955078, + "lyap1_max": -10.010568618774414, + "lyap_spec_mean": [ + -10.525592803955078, + -10.758855819702148 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2101, + "lr": 0.0001, + "sup_loss": 1.5370520249385466 + }, + { + "step": 2102, + "lr": 0.0001, + "sup_loss": 1.5471082667136808 + }, + { + "step": 2103, + "lr": 0.0001, + "sup_loss": 1.4959041339755241 + }, + { + "step": 2104, + "lr": 0.0001, + "sup_loss": 1.5058752462810896 + }, + { + "step": 2105, + "lr": 0.0001, + "sup_loss": 1.555946638415964 + }, + { + "step": 2106, + "lr": 0.0001, + "sup_loss": 1.4828218029406843 + }, + { + "step": 2107, + "lr": 0.0001, + "sup_loss": 1.5041661423123902 + }, + { + "step": 2108, + "lr": 0.0001, + "sup_loss": 1.5135068886856151 + }, + { + "step": 2109, + "lr": 0.0001, + "sup_loss": 1.496125847816772 + }, + { + "step": 2110, + "lr": 0.0001, + "sup_loss": 1.5100093323237058 + }, + { + "step": 2111, + "lr": 0.0001, + "sup_loss": 1.4858521134032618 + }, + { + "step": 2112, + "lr": 0.0001, + "sup_loss": 1.5063659145448416 + }, + { + "step": 2113, + "lr": 0.0001, + "sup_loss": 1.517060901956673 + }, + { + "step": 2114, + "lr": 0.0001, + "sup_loss": 1.526396629497423 + }, + { + "step": 2115, + "lr": 0.0001, + "sup_loss": 1.5163947656476848 + }, + { + "step": 2116, + "lr": 0.0001, + "sup_loss": 1.5035832719722275 + }, + { + "step": 2117, + "lr": 0.0001, + "sup_loss": 1.4825362611458814 + }, + { + "step": 2118, + "lr": 0.0001, + "sup_loss": 1.5025646466230649 + }, + { + "step": 2119, + "lr": 0.0001, + "sup_loss": 1.4630544810627801 + }, + { + "step": 2120, + "lr": 0.0001, + "sup_loss": 1.499647693765966 + }, + { + "step": 2121, + "lr": 0.0001, + "sup_loss": 1.5303422696698479 + }, + { + "step": 2122, + "lr": 0.0001, + "sup_loss": 1.5159357145681078 + }, + { + "step": 2123, + "lr": 0.0001, + "sup_loss": 1.4925102760461895 + }, + { + "step": 2124, + "lr": 0.0001, + "sup_loss": 1.4956946436939247 + }, + { + "step": 2125, + "lr": 0.0001, + "sup_loss": 1.5160389168532975 + }, + { + "step": 2126, + "lr": 0.0001, + "sup_loss": 1.5301130072080806 + }, + { + "step": 2127, + "lr": 0.0001, + "sup_loss": 1.4899894369576205 + }, + { + "step": 2128, + "lr": 0.0001, + "sup_loss": 1.5259811017631164 + }, + { + "step": 2129, + "lr": 0.0001, + "sup_loss": 1.529855654876286 + }, + { + "step": 2130, + "lr": 0.0001, + "sup_loss": 1.5088865459048497 + }, + { + "step": 2131, + "lr": 0.0001, + "sup_loss": 1.5159644064745523 + }, + { + "step": 2132, + "lr": 0.0001, + "sup_loss": 1.5231021975800803 + }, + { + "step": 2133, + "lr": 0.0001, + "sup_loss": 1.5132066529541186 + }, + { + "step": 2134, + "lr": 0.0001, + "sup_loss": 1.4659945222037551 + }, + { + "step": 2135, + "lr": 0.0001, + "sup_loss": 1.5305079256270608 + }, + { + "step": 2136, + "lr": 0.0001, + "sup_loss": 1.4927190686480603 + }, + { + "step": 2137, + "lr": 0.0001, + "sup_loss": 1.5171019285834968 + }, + { + "step": 2138, + "lr": 0.0001, + "sup_loss": 1.5127600744971834 + }, + { + "step": 2139, + "lr": 0.0001, + "sup_loss": 1.4889544834135184 + }, + { + "step": 2140, + "lr": 0.0001, + "sup_loss": 1.500111247647175 + }, + { + "step": 2141, + "lr": 0.0001, + "sup_loss": 1.5471158602670942 + }, + { + "step": 2142, + "lr": 0.0001, + "sup_loss": 1.4996514120978899 + }, + { + "step": 2143, + "lr": 0.0001, + "sup_loss": 1.550008331211554 + }, + { + "step": 2144, + "lr": 0.0001, + "sup_loss": 1.4873505259819735 + }, + { + "step": 2145, + "lr": 0.0001, + "sup_loss": 1.5398754910673564 + }, + { + "step": 2146, + "lr": 0.0001, + "sup_loss": 1.496666844120577 + }, + { + "step": 2147, + "lr": 0.0001, + "sup_loss": 1.5306110722427586 + }, + { + "step": 2148, + "lr": 0.0001, + "sup_loss": 1.4999688902717947 + }, + { + "step": 2149, + "lr": 0.0001, + "sup_loss": 1.509812684887154 + }, + { + "step": 2150, + "lr": 0.0001, + "sup_loss": 1.5341005065095945, + "lyap1_mean": -10.414691925048828, + "lyap1_max": -9.885202407836914, + "lyap_spec_mean": [ + -10.414691925048828, + -10.704854965209961 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2151, + "lr": 0.0001, + "sup_loss": 1.513350407572845 + }, + { + "step": 2152, + "lr": 0.0001, + "sup_loss": 1.5366645783678592 + }, + { + "step": 2153, + "lr": 0.0001, + "sup_loss": 1.5055996182543072 + }, + { + "step": 2154, + "lr": 0.0001, + "sup_loss": 1.5303881373556651 + }, + { + "step": 2155, + "lr": 0.0001, + "sup_loss": 1.49655485758877 + }, + { + "step": 2156, + "lr": 0.0001, + "sup_loss": 1.4921080470741925 + }, + { + "step": 2157, + "lr": 0.0001, + "sup_loss": 1.5088365489912474 + }, + { + "step": 2158, + "lr": 0.0001, + "sup_loss": 1.512805684670145 + }, + { + "step": 2159, + "lr": 0.0001, + "sup_loss": 1.5237878854150253 + }, + { + "step": 2160, + "lr": 0.0001, + "sup_loss": 1.5330496819537938 + }, + { + "step": 2161, + "lr": 0.0001, + "sup_loss": 1.5123853004290455 + }, + { + "step": 2162, + "lr": 0.0001, + "sup_loss": 1.5233805082702503 + }, + { + "step": 2163, + "lr": 0.0001, + "sup_loss": 1.4552607382254648 + }, + { + "step": 2164, + "lr": 0.0001, + "sup_loss": 1.5268393349618352 + }, + { + "step": 2165, + "lr": 0.0001, + "sup_loss": 1.550723281129827 + }, + { + "step": 2166, + "lr": 0.0001, + "sup_loss": 1.533102374374384 + }, + { + "step": 2167, + "lr": 0.0001, + "sup_loss": 1.5069340091355101 + }, + { + "step": 2168, + "lr": 0.0001, + "sup_loss": 1.5064339804313032 + }, + { + "step": 2169, + "lr": 0.0001, + "sup_loss": 1.5023787896622416 + }, + { + "step": 2170, + "lr": 0.0001, + "sup_loss": 1.5162458819135196 + }, + { + "step": 2171, + "lr": 0.0001, + "sup_loss": 1.4933277938837495 + }, + { + "step": 2172, + "lr": 0.0001, + "sup_loss": 1.5224142957109872 + }, + { + "step": 2173, + "lr": 0.0001, + "sup_loss": 1.5431448351075447 + }, + { + "step": 2174, + "lr": 0.0001, + "sup_loss": 1.5333154859745879 + }, + { + "step": 2175, + "lr": 0.0001, + "sup_loss": 1.5128842361905455 + }, + { + "step": 2176, + "lr": 0.0001, + "sup_loss": 1.5124976540516892 + }, + { + "step": 2177, + "lr": 0.0001, + "sup_loss": 1.5300409702172502 + }, + { + "step": 2178, + "lr": 0.0001, + "sup_loss": 1.4951080321298196 + }, + { + "step": 2179, + "lr": 0.0001, + "sup_loss": 1.5172640447977481 + }, + { + "step": 2180, + "lr": 0.0001, + "sup_loss": 1.509106007203832 + }, + { + "step": 2181, + "lr": 0.0001, + "sup_loss": 1.5033778987653441 + }, + { + "step": 2182, + "lr": 0.0001, + "sup_loss": 1.4735838829901131 + }, + { + "step": 2183, + "lr": 0.0001, + "sup_loss": 1.5263702029051203 + }, + { + "step": 2184, + "lr": 0.0001, + "sup_loss": 1.496340374123101 + }, + { + "step": 2185, + "lr": 0.0001, + "sup_loss": 1.52165705621513 + }, + { + "step": 2186, + "lr": 0.0001, + "sup_loss": 1.5302225221521526 + }, + { + "step": 2187, + "lr": 0.0001, + "sup_loss": 1.5358596667188529 + }, + { + "step": 2188, + "lr": 0.0001, + "sup_loss": 1.4956344931525294 + }, + { + "step": 2189, + "lr": 0.0001, + "sup_loss": 1.5534141269358048 + }, + { + "step": 2190, + "lr": 0.0001, + "sup_loss": 1.4927876203305774 + }, + { + "step": 2191, + "lr": 0.0001, + "sup_loss": 1.4687736255207693 + }, + { + "step": 2192, + "lr": 0.0001, + "sup_loss": 1.5032045102134572 + }, + { + "step": 2193, + "lr": 0.0001, + "sup_loss": 1.496064516447394 + }, + { + "step": 2194, + "lr": 0.0001, + "sup_loss": 1.5165584517432824 + }, + { + "step": 2195, + "lr": 0.0001, + "sup_loss": 1.4953203675270395 + }, + { + "step": 2196, + "lr": 0.0001, + "sup_loss": 1.4381751752718088 + }, + { + "step": 2197, + "lr": 0.0001, + "sup_loss": 1.4625203738675139 + }, + { + "step": 2198, + "lr": 0.0001, + "sup_loss": 1.4716455832825492 + }, + { + "step": 2199, + "lr": 0.0001, + "sup_loss": 1.4619753972008183 + }, + { + "step": 2200, + "lr": 0.0001, + "sup_loss": 1.5343946237223018, + "lyap1_mean": -9.857443809509277, + "lyap1_max": -9.285022735595703, + "lyap_spec_mean": [ + -9.857443809509277, + -10.554052352905273 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2201, + "lr": 0.0001, + "sup_loss": 1.493445131550346 + }, + { + "step": 2202, + "lr": 0.0001, + "sup_loss": 1.5204819457823944 + }, + { + "step": 2203, + "lr": 0.0001, + "sup_loss": 1.4859665352971843 + }, + { + "step": 2204, + "lr": 0.0001, + "sup_loss": 1.5199175007994195 + }, + { + "step": 2205, + "lr": 0.0001, + "sup_loss": 1.458638123564083 + }, + { + "step": 2206, + "lr": 0.0001, + "sup_loss": 1.4937221853542337 + }, + { + "step": 2207, + "lr": 0.0001, + "sup_loss": 1.5367229238073508 + }, + { + "step": 2208, + "lr": 0.0001, + "sup_loss": 1.5066057317173986 + }, + { + "step": 2209, + "lr": 0.0001, + "sup_loss": 1.5237427727044424 + }, + { + "step": 2210, + "lr": 0.0001, + "sup_loss": 1.5297851744290072 + }, + { + "step": 2211, + "lr": 0.0001, + "sup_loss": 1.502942969520986 + }, + { + "step": 2212, + "lr": 0.0001, + "sup_loss": 1.5174242401239477 + }, + { + "step": 2213, + "lr": 0.0001, + "sup_loss": 1.5473072601940956 + }, + { + "step": 2214, + "lr": 0.0001, + "sup_loss": 1.4926185092687234 + }, + { + "step": 2215, + "lr": 0.0001, + "sup_loss": 1.5533541263117907 + }, + { + "step": 2216, + "lr": 0.0001, + "sup_loss": 1.5127761197892202 + }, + { + "step": 2217, + "lr": 0.0001, + "sup_loss": 1.4852458868716976 + }, + { + "step": 2218, + "lr": 0.0001, + "sup_loss": 1.51963743976625 + }, + { + "step": 2219, + "lr": 0.0001, + "sup_loss": 1.536506328394379 + }, + { + "step": 2220, + "lr": 0.0001, + "sup_loss": 1.5256533451325693 + }, + { + "step": 2221, + "lr": 0.0001, + "sup_loss": 1.5200113807476625 + }, + { + "step": 2222, + "lr": 0.0001, + "sup_loss": 1.5134892457851374 + }, + { + "step": 2223, + "lr": 0.0001, + "sup_loss": 1.5128043688747477 + }, + { + "step": 2224, + "lr": 0.0001, + "sup_loss": 1.527178443645706 + }, + { + "step": 2225, + "lr": 0.0001, + "sup_loss": 1.489877133694634 + }, + { + "step": 2226, + "lr": 0.0001, + "sup_loss": 1.5335585548543211 + }, + { + "step": 2227, + "lr": 0.0001, + "sup_loss": 1.5233181606640342 + }, + { + "step": 2228, + "lr": 0.0001, + "sup_loss": 1.4856133528911215 + }, + { + "step": 2229, + "lr": 0.0001, + "sup_loss": 1.512646079320785 + }, + { + "step": 2230, + "lr": 0.0001, + "sup_loss": 1.4853290939369814 + }, + { + "step": 2231, + "lr": 0.0001, + "sup_loss": 1.5298486015456372 + }, + { + "step": 2232, + "lr": 0.0001, + "sup_loss": 1.5329825060613378 + }, + { + "step": 2233, + "lr": 0.0001, + "sup_loss": 1.5187389616520404 + }, + { + "step": 2234, + "lr": 0.0001, + "sup_loss": 1.5071647520089257 + }, + { + "step": 2235, + "lr": 0.0001, + "sup_loss": 1.4989563318894132 + }, + { + "step": 2236, + "lr": 0.0001, + "sup_loss": 1.502590198122387 + }, + { + "step": 2237, + "lr": 0.0001, + "sup_loss": 1.5033627914969294 + }, + { + "step": 2238, + "lr": 0.0001, + "sup_loss": 1.5230011816534 + }, + { + "step": 2239, + "lr": 0.0001, + "sup_loss": 1.5167958077536312 + }, + { + "step": 2240, + "lr": 0.0001, + "sup_loss": 1.5086131220402772 + }, + { + "step": 2241, + "lr": 0.0001, + "sup_loss": 1.5028902893256424 + }, + { + "step": 2242, + "lr": 0.0001, + "sup_loss": 1.5050323384350919 + }, + { + "step": 2243, + "lr": 0.0001, + "sup_loss": 1.5403038812966345 + }, + { + "step": 2244, + "lr": 0.0001, + "sup_loss": 1.5307658812164049 + }, + { + "step": 2245, + "lr": 0.0001, + "sup_loss": 1.5296970973263389 + }, + { + "step": 2246, + "lr": 0.0001, + "sup_loss": 1.5289671477125684 + }, + { + "step": 2247, + "lr": 0.0001, + "sup_loss": 1.485658250081715 + }, + { + "step": 2248, + "lr": 0.0001, + "sup_loss": 1.509848616782357 + }, + { + "step": 2249, + "lr": 0.0001, + "sup_loss": 1.5089231758443586 + }, + { + "step": 2250, + "lr": 0.0001, + "sup_loss": 1.4891335841952535, + "lyap1_mean": -9.766853332519531, + "lyap1_max": -9.470773696899414, + "lyap_spec_mean": [ + -9.766853332519531, + -10.40333080291748 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2251, + "lr": 0.0001, + "sup_loss": 1.480034102582459 + }, + { + "step": 2252, + "lr": 0.0001, + "sup_loss": 1.505524274296499 + }, + { + "step": 2253, + "lr": 0.0001, + "sup_loss": 1.5266200607922433 + }, + { + "step": 2254, + "lr": 0.0001, + "sup_loss": 1.5231316305011264 + }, + { + "step": 2255, + "lr": 0.0001, + "sup_loss": 1.4891715905444087 + }, + { + "step": 2256, + "lr": 0.0001, + "sup_loss": 1.506109590288865 + }, + { + "step": 2257, + "lr": 0.0001, + "sup_loss": 1.4751331569882173 + }, + { + "step": 2258, + "lr": 0.0001, + "sup_loss": 1.5063949874186153 + }, + { + "step": 2259, + "lr": 0.0001, + "sup_loss": 1.4515670000296657 + }, + { + "step": 2260, + "lr": 0.0001, + "sup_loss": 1.5097836702498053 + }, + { + "step": 2261, + "lr": 0.0001, + "sup_loss": 1.5266053625901794 + }, + { + "step": 2262, + "lr": 0.0001, + "sup_loss": 1.5299457172963797 + }, + { + "step": 2263, + "lr": 0.0001, + "sup_loss": 1.5366608340919325 + }, + { + "step": 2264, + "lr": 0.0001, + "sup_loss": 1.499398794205034 + }, + { + "step": 2265, + "lr": 0.0001, + "sup_loss": 1.4650755375309752 + }, + { + "step": 2266, + "lr": 0.0001, + "sup_loss": 1.4984345620203439 + }, + { + "step": 2267, + "lr": 0.0001, + "sup_loss": 1.5433063455832954 + }, + { + "step": 2268, + "lr": 0.0001, + "sup_loss": 1.5169616679921556 + }, + { + "step": 2269, + "lr": 0.0001, + "sup_loss": 1.5331533123900245 + }, + { + "step": 2270, + "lr": 0.0001, + "sup_loss": 1.5032191789256215 + }, + { + "step": 2271, + "lr": 0.0001, + "sup_loss": 1.4887115057435334 + }, + { + "step": 2272, + "lr": 0.0001, + "sup_loss": 1.539920955391536 + }, + { + "step": 2273, + "lr": 0.0001, + "sup_loss": 1.5136500001203796 + }, + { + "step": 2274, + "lr": 0.0001, + "sup_loss": 1.5129437365497895 + }, + { + "step": 2275, + "lr": 0.0001, + "sup_loss": 1.5093358540952766 + }, + { + "step": 2276, + "lr": 0.0001, + "sup_loss": 1.529948439625662 + }, + { + "step": 2277, + "lr": 0.0001, + "sup_loss": 1.4959265779383775 + }, + { + "step": 2278, + "lr": 0.0001, + "sup_loss": 1.5304547369051527 + }, + { + "step": 2279, + "lr": 0.0001, + "sup_loss": 1.5323890418162793 + }, + { + "step": 2280, + "lr": 0.0001, + "sup_loss": 1.4962264970360466 + }, + { + "step": 2281, + "lr": 0.0001, + "sup_loss": 1.5232671743270731 + }, + { + "step": 2282, + "lr": 0.0001, + "sup_loss": 1.4986308819032994 + }, + { + "step": 2283, + "lr": 0.0001, + "sup_loss": 1.560731178205112 + }, + { + "step": 2284, + "lr": 0.0001, + "sup_loss": 1.482941108641339 + }, + { + "step": 2285, + "lr": 0.0001, + "sup_loss": 1.4965560049843911 + }, + { + "step": 2286, + "lr": 0.0001, + "sup_loss": 1.5141147099734613 + }, + { + "step": 2287, + "lr": 0.0001, + "sup_loss": 1.5466405166817379 + }, + { + "step": 2288, + "lr": 0.0001, + "sup_loss": 1.516930397876688 + }, + { + "step": 2289, + "lr": 0.0001, + "sup_loss": 1.5061480591991812 + }, + { + "step": 2290, + "lr": 0.0001, + "sup_loss": 1.5021234389000104 + }, + { + "step": 2291, + "lr": 0.0001, + "sup_loss": 1.5231088373084478 + }, + { + "step": 2292, + "lr": 0.0001, + "sup_loss": 1.5159935727265366 + }, + { + "step": 2293, + "lr": 0.0001, + "sup_loss": 1.462117218509128 + }, + { + "step": 2294, + "lr": 0.0001, + "sup_loss": 1.503415431150131 + }, + { + "step": 2295, + "lr": 0.0001, + "sup_loss": 1.4933703820043436 + }, + { + "step": 2296, + "lr": 0.0001, + "sup_loss": 1.515990706477299 + }, + { + "step": 2297, + "lr": 0.0001, + "sup_loss": 1.5302406144418423 + }, + { + "step": 2298, + "lr": 0.0001, + "sup_loss": 1.475610093842603 + }, + { + "step": 2299, + "lr": 0.0001, + "sup_loss": 1.5061719606256854 + }, + { + "step": 2300, + "lr": 0.0001, + "sup_loss": 1.5357619478572675, + "lyap1_mean": -9.916058540344238, + "lyap1_max": -9.622955322265625, + "lyap_spec_mean": [ + -9.916058540344238, + -10.319125175476074 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2301, + "lr": 0.0001, + "sup_loss": 1.5139354500028037 + }, + { + "step": 2302, + "lr": 0.0001, + "sup_loss": 1.4959533211932847 + }, + { + "step": 2303, + "lr": 0.0001, + "sup_loss": 1.4960883968148364 + }, + { + "step": 2304, + "lr": 0.0001, + "sup_loss": 1.527036414938187 + }, + { + "step": 2305, + "lr": 0.0001, + "sup_loss": 1.493802005833204 + }, + { + "step": 2306, + "lr": 0.0001, + "sup_loss": 1.5031447296663778 + }, + { + "step": 2307, + "lr": 0.0001, + "sup_loss": 1.4958656009695743 + }, + { + "step": 2308, + "lr": 0.0001, + "sup_loss": 1.5160499900831392 + }, + { + "step": 2309, + "lr": 0.0001, + "sup_loss": 1.5128114978414995 + }, + { + "step": 2310, + "lr": 0.0001, + "sup_loss": 1.5434024076273272 + }, + { + "step": 2311, + "lr": 0.0001, + "sup_loss": 1.516145080010433 + }, + { + "step": 2312, + "lr": 0.0001, + "sup_loss": 1.522729234192683 + }, + { + "step": 2313, + "lr": 0.0001, + "sup_loss": 1.5024336516280041 + }, + { + "step": 2314, + "lr": 0.0001, + "sup_loss": 1.5224521756742495 + }, + { + "step": 2315, + "lr": 0.0001, + "sup_loss": 1.5191279181863753 + }, + { + "step": 2316, + "lr": 0.0001, + "sup_loss": 1.5203993500386943 + }, + { + "step": 2317, + "lr": 0.0001, + "sup_loss": 1.506061557359626 + }, + { + "step": 2318, + "lr": 0.0001, + "sup_loss": 1.499381754796754 + }, + { + "step": 2319, + "lr": 0.0001, + "sup_loss": 1.530599893440627 + }, + { + "step": 2320, + "lr": 0.0001, + "sup_loss": 1.5166384455171322 + }, + { + "step": 2321, + "lr": 0.0001, + "sup_loss": 1.5166659280584196 + }, + { + "step": 2322, + "lr": 0.0001, + "sup_loss": 1.5365309421499316 + }, + { + "step": 2323, + "lr": 0.0001, + "sup_loss": 1.5051887590110162 + }, + { + "step": 2324, + "lr": 0.0001, + "sup_loss": 1.5155005920457045 + }, + { + "step": 2325, + "lr": 0.0001, + "sup_loss": 1.4992984658163864 + }, + { + "step": 2326, + "lr": 0.0001, + "sup_loss": 1.5070833411999778 + }, + { + "step": 2327, + "lr": 0.0001, + "sup_loss": 1.4793606102871382 + }, + { + "step": 2328, + "lr": 0.0001, + "sup_loss": 1.5439257310397736 + }, + { + "step": 2329, + "lr": 0.0001, + "sup_loss": 1.519174070358913 + }, + { + "step": 2330, + "lr": 0.0001, + "sup_loss": 1.4757174692057402 + }, + { + "step": 2331, + "lr": 0.0001, + "sup_loss": 1.4911902159107253 + }, + { + "step": 2332, + "lr": 0.0001, + "sup_loss": 1.5508543790267835 + }, + { + "step": 2333, + "lr": 0.0001, + "sup_loss": 1.5194658507576362 + }, + { + "step": 2334, + "lr": 0.0001, + "sup_loss": 1.516290869947371 + }, + { + "step": 2335, + "lr": 0.0001, + "sup_loss": 1.4995380582398614 + }, + { + "step": 2336, + "lr": 0.0001, + "sup_loss": 1.4989513822787683 + }, + { + "step": 2337, + "lr": 0.0001, + "sup_loss": 1.5201051330832993 + }, + { + "step": 2338, + "lr": 0.0001, + "sup_loss": 1.492758469067659 + }, + { + "step": 2339, + "lr": 0.0001, + "sup_loss": 1.4790321909989035 + }, + { + "step": 2340, + "lr": 0.0001, + "sup_loss": 1.5161776726262215 + }, + { + "step": 2341, + "lr": 0.0001, + "sup_loss": 1.524556617441932 + }, + { + "step": 2342, + "lr": 0.0001, + "sup_loss": 1.5103023139083787 + }, + { + "step": 2343, + "lr": 0.0001, + "sup_loss": 1.5029924592303003 + }, + { + "step": 2344, + "lr": 0.0001, + "sup_loss": 1.5177958617775054 + }, + { + "step": 2345, + "lr": 0.0001, + "sup_loss": 1.52275715818389 + }, + { + "step": 2346, + "lr": 0.0001, + "sup_loss": 1.5060484892023114 + }, + { + "step": 2347, + "lr": 0.0001, + "sup_loss": 1.4789709095683994 + }, + { + "step": 2348, + "lr": 0.0001, + "sup_loss": 1.5121737703860245 + }, + { + "step": 2349, + "lr": 0.0001, + "sup_loss": 1.4558737794652428 + }, + { + "step": 2350, + "lr": 0.0001, + "sup_loss": 1.5101342801744093, + "lyap1_mean": -9.51066780090332, + "lyap1_max": -9.105236053466797, + "lyap_spec_mean": [ + -9.51066780090332, + -9.912164688110352 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2351, + "lr": 0.0001, + "sup_loss": 1.5477349726769523 + }, + { + "step": 2352, + "lr": 0.0001, + "sup_loss": 1.5105477766900295 + }, + { + "step": 2353, + "lr": 0.0001, + "sup_loss": 1.5226079423247705 + }, + { + "step": 2354, + "lr": 0.0001, + "sup_loss": 1.5070101739453396 + }, + { + "step": 2355, + "lr": 0.0001, + "sup_loss": 1.519610871334335 + }, + { + "step": 2356, + "lr": 0.0001, + "sup_loss": 1.5163556157791183 + }, + { + "step": 2357, + "lr": 0.0001, + "sup_loss": 1.5198566642536202 + }, + { + "step": 2358, + "lr": 0.0001, + "sup_loss": 1.5037111992752081 + }, + { + "step": 2359, + "lr": 0.0001, + "sup_loss": 1.489142003003933 + }, + { + "step": 2360, + "lr": 0.0001, + "sup_loss": 1.5062257248399338 + }, + { + "step": 2361, + "lr": 0.0001, + "sup_loss": 1.5567702589849843 + }, + { + "step": 2362, + "lr": 0.0001, + "sup_loss": 1.516268831313906 + }, + { + "step": 2363, + "lr": 0.0001, + "sup_loss": 1.5426154264980476 + }, + { + "step": 2364, + "lr": 0.0001, + "sup_loss": 1.4986958518842 + }, + { + "step": 2365, + "lr": 0.0001, + "sup_loss": 1.513460476956936 + }, + { + "step": 2366, + "lr": 0.0001, + "sup_loss": 1.495795443312932 + }, + { + "step": 2367, + "lr": 0.0001, + "sup_loss": 1.5063115062098569 + }, + { + "step": 2368, + "lr": 0.0001, + "sup_loss": 1.5163832235709587 + }, + { + "step": 2369, + "lr": 0.0001, + "sup_loss": 1.5237364299335323 + }, + { + "step": 2370, + "lr": 0.0001, + "sup_loss": 1.5014872213875217 + }, + { + "step": 2371, + "lr": 0.0001, + "sup_loss": 1.496289725906565 + }, + { + "step": 2372, + "lr": 0.0001, + "sup_loss": 1.4993948166269004 + }, + { + "step": 2373, + "lr": 0.0001, + "sup_loss": 1.4828897469835 + }, + { + "step": 2374, + "lr": 0.0001, + "sup_loss": 1.5429622900511502 + }, + { + "step": 2375, + "lr": 0.0001, + "sup_loss": 1.5442038292325597 + }, + { + "step": 2376, + "lr": 0.0001, + "sup_loss": 1.519787462075779 + }, + { + "step": 2377, + "lr": 0.0001, + "sup_loss": 1.5069092125042107 + }, + { + "step": 2378, + "lr": 0.0001, + "sup_loss": 1.4896603134988151 + }, + { + "step": 2379, + "lr": 0.0001, + "sup_loss": 1.4783122247219576 + }, + { + "step": 2380, + "lr": 0.0001, + "sup_loss": 1.473341355609945 + }, + { + "step": 2381, + "lr": 0.0001, + "sup_loss": 1.5134364670294744 + }, + { + "step": 2382, + "lr": 0.0001, + "sup_loss": 1.5299928331045687 + }, + { + "step": 2383, + "lr": 0.0001, + "sup_loss": 1.5195843255787462 + }, + { + "step": 2384, + "lr": 0.0001, + "sup_loss": 1.4646261664351339 + }, + { + "step": 2385, + "lr": 0.0001, + "sup_loss": 1.523079719017832 + }, + { + "step": 2386, + "lr": 0.0001, + "sup_loss": 1.5132288410008796 + }, + { + "step": 2387, + "lr": 0.0001, + "sup_loss": 1.5228700965785704 + }, + { + "step": 2388, + "lr": 0.0001, + "sup_loss": 1.4458923167768771 + }, + { + "step": 2389, + "lr": 0.0001, + "sup_loss": 1.5133971636663759 + }, + { + "step": 2390, + "lr": 0.0001, + "sup_loss": 1.5133584400002986 + }, + { + "step": 2391, + "lr": 0.0001, + "sup_loss": 1.5440856131071545 + }, + { + "step": 2392, + "lr": 0.0001, + "sup_loss": 1.484875539927131 + }, + { + "step": 2393, + "lr": 0.0001, + "sup_loss": 1.5135481781701392 + }, + { + "step": 2394, + "lr": 0.0001, + "sup_loss": 1.5197577513626626 + }, + { + "step": 2395, + "lr": 0.0001, + "sup_loss": 1.5167274925285237 + }, + { + "step": 2396, + "lr": 0.0001, + "sup_loss": 1.489264774127612 + }, + { + "step": 2397, + "lr": 0.0001, + "sup_loss": 1.5130725406616534 + }, + { + "step": 2398, + "lr": 0.0001, + "sup_loss": 1.5155172323391153 + }, + { + "step": 2399, + "lr": 0.0001, + "sup_loss": 1.4956741126993633 + }, + { + "step": 2400, + "lr": 0.0001, + "sup_loss": 1.519551817562562, + "lyap1_mean": -9.637104988098145, + "lyap1_max": -9.343791961669922, + "lyap_spec_mean": [ + -9.637105941772461, + -10.045071601867676 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2401, + "lr": 0.0001, + "sup_loss": 1.5308561969849703 + }, + { + "step": 2402, + "lr": 0.0001, + "sup_loss": 1.5268637463561776 + }, + { + "step": 2403, + "lr": 0.0001, + "sup_loss": 1.5268676035205422 + }, + { + "step": 2404, + "lr": 0.0001, + "sup_loss": 1.5061623047058001 + }, + { + "step": 2405, + "lr": 0.0001, + "sup_loss": 1.519639967432187 + }, + { + "step": 2406, + "lr": 0.0001, + "sup_loss": 1.5058637555170122 + }, + { + "step": 2407, + "lr": 0.0001, + "sup_loss": 1.5027935326753055 + }, + { + "step": 2408, + "lr": 0.0001, + "sup_loss": 1.5203825609662216 + }, + { + "step": 2409, + "lr": 0.0001, + "sup_loss": 1.5198701782999993 + }, + { + "step": 2410, + "lr": 0.0001, + "sup_loss": 1.4965089624876216 + }, + { + "step": 2411, + "lr": 0.0001, + "sup_loss": 1.485345912429913 + }, + { + "step": 2412, + "lr": 0.0001, + "sup_loss": 1.4817987196670022 + }, + { + "step": 2413, + "lr": 0.0001, + "sup_loss": 1.5265164155043867 + }, + { + "step": 2414, + "lr": 0.0001, + "sup_loss": 1.5299220329271734 + }, + { + "step": 2415, + "lr": 0.0001, + "sup_loss": 1.5329349522249556 + }, + { + "step": 2416, + "lr": 0.0001, + "sup_loss": 1.4861000494445213 + }, + { + "step": 2417, + "lr": 0.0001, + "sup_loss": 1.5064133288055823 + }, + { + "step": 2418, + "lr": 0.0001, + "sup_loss": 1.5231147172216224 + }, + { + "step": 2419, + "lr": 0.0001, + "sup_loss": 1.5160867359084802 + }, + { + "step": 2420, + "lr": 0.0001, + "sup_loss": 1.5068218472808244 + }, + { + "step": 2421, + "lr": 0.0001, + "sup_loss": 1.520141073606864 + }, + { + "step": 2422, + "lr": 0.0001, + "sup_loss": 1.4871436596766163 + }, + { + "step": 2423, + "lr": 0.0001, + "sup_loss": 1.5327485431139187 + }, + { + "step": 2424, + "lr": 0.0001, + "sup_loss": 1.4828737962960328 + }, + { + "step": 2425, + "lr": 0.0001, + "sup_loss": 1.5058719310849757 + }, + { + "step": 2426, + "lr": 0.0001, + "sup_loss": 1.5060537723108103 + }, + { + "step": 2427, + "lr": 0.0001, + "sup_loss": 1.5327269424396006 + }, + { + "step": 2428, + "lr": 0.0001, + "sup_loss": 1.5021456447621626 + }, + { + "step": 2429, + "lr": 0.0001, + "sup_loss": 1.5229766626109897 + }, + { + "step": 2430, + "lr": 0.0001, + "sup_loss": 1.4988891108980598 + }, + { + "step": 2431, + "lr": 0.0001, + "sup_loss": 1.5096935781852885 + }, + { + "step": 2432, + "lr": 0.0001, + "sup_loss": 1.518988063517708 + }, + { + "step": 2433, + "lr": 0.0001, + "sup_loss": 1.5201295108706494 + }, + { + "step": 2434, + "lr": 0.0001, + "sup_loss": 1.5228754088938823 + }, + { + "step": 2435, + "lr": 0.0001, + "sup_loss": 1.4688383683806858 + }, + { + "step": 2436, + "lr": 0.0001, + "sup_loss": 1.4826059845432336 + }, + { + "step": 2437, + "lr": 0.0001, + "sup_loss": 1.5546312424281725 + }, + { + "step": 2438, + "lr": 0.0001, + "sup_loss": 1.5231559706459543 + }, + { + "step": 2439, + "lr": 0.0001, + "sup_loss": 1.4991198498100546 + }, + { + "step": 2440, + "lr": 0.0001, + "sup_loss": 1.4932036149812264 + }, + { + "step": 2441, + "lr": 0.0001, + "sup_loss": 1.5340974909072556 + }, + { + "step": 2442, + "lr": 0.0001, + "sup_loss": 1.4853288216878655 + }, + { + "step": 2443, + "lr": 0.0001, + "sup_loss": 1.5603897025621765 + }, + { + "step": 2444, + "lr": 0.0001, + "sup_loss": 1.5195048707271988 + }, + { + "step": 2445, + "lr": 0.0001, + "sup_loss": 1.4993515185760766 + }, + { + "step": 2446, + "lr": 0.0001, + "sup_loss": 1.52325801596691 + }, + { + "step": 2447, + "lr": 0.0001, + "sup_loss": 1.5057915053452873 + }, + { + "step": 2448, + "lr": 0.0001, + "sup_loss": 1.4994944712746108 + }, + { + "step": 2449, + "lr": 0.0001, + "sup_loss": 1.5236857331330342 + }, + { + "step": 2450, + "lr": 0.0001, + "sup_loss": 1.5374149753237705, + "lyap1_mean": -9.324481964111328, + "lyap1_max": -9.186753273010254, + "lyap_spec_mean": [ + -9.324481010437012, + -10.160441398620605 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2451, + "lr": 0.0001, + "sup_loss": 1.502750370344381 + }, + { + "step": 2452, + "lr": 0.0001, + "sup_loss": 1.4851696765358084 + }, + { + "step": 2453, + "lr": 0.0001, + "sup_loss": 1.51936911721008 + }, + { + "step": 2454, + "lr": 0.0001, + "sup_loss": 1.495082153332659 + }, + { + "step": 2455, + "lr": 0.0001, + "sup_loss": 1.4890377506288948 + }, + { + "step": 2456, + "lr": 0.0001, + "sup_loss": 1.5503782037465512 + }, + { + "step": 2457, + "lr": 0.0001, + "sup_loss": 1.5330810521823834 + }, + { + "step": 2458, + "lr": 0.0001, + "sup_loss": 1.523399654336997 + }, + { + "step": 2459, + "lr": 0.0001, + "sup_loss": 1.5023506356526262 + }, + { + "step": 2460, + "lr": 0.0001, + "sup_loss": 1.5101897411203158 + }, + { + "step": 2461, + "lr": 0.0001, + "sup_loss": 1.490034720308003 + }, + { + "step": 2462, + "lr": 0.0001, + "sup_loss": 1.550218248810576 + }, + { + "step": 2463, + "lr": 0.0001, + "sup_loss": 1.4825796087058687 + }, + { + "step": 2464, + "lr": 0.0001, + "sup_loss": 1.5370379949600566 + }, + { + "step": 2465, + "lr": 0.0001, + "sup_loss": 1.4987093143685317 + }, + { + "step": 2466, + "lr": 0.0001, + "sup_loss": 1.509332285148993 + }, + { + "step": 2467, + "lr": 0.0001, + "sup_loss": 1.4959190827636488 + }, + { + "step": 2468, + "lr": 0.0001, + "sup_loss": 1.536854849320798 + }, + { + "step": 2469, + "lr": 0.0001, + "sup_loss": 1.4965721660311395 + }, + { + "step": 2470, + "lr": 0.0001, + "sup_loss": 1.5050898566810331 + }, + { + "step": 2471, + "lr": 0.0001, + "sup_loss": 1.531090868204679 + }, + { + "step": 2472, + "lr": 0.0001, + "sup_loss": 1.5266257636028477 + }, + { + "step": 2473, + "lr": 0.0001, + "sup_loss": 1.530598202611122 + }, + { + "step": 2474, + "lr": 0.0001, + "sup_loss": 1.5458675792013852 + }, + { + "step": 2475, + "lr": 0.0001, + "sup_loss": 1.4922485325454882 + }, + { + "step": 2476, + "lr": 0.0001, + "sup_loss": 1.5121426914830676 + }, + { + "step": 2477, + "lr": 0.0001, + "sup_loss": 1.5263674818521245 + }, + { + "step": 2478, + "lr": 0.0001, + "sup_loss": 1.5508584002518178 + }, + { + "step": 2479, + "lr": 0.0001, + "sup_loss": 1.539365885127396 + }, + { + "step": 2480, + "lr": 0.0001, + "sup_loss": 1.4865130503781203 + }, + { + "step": 2481, + "lr": 0.0001, + "sup_loss": 1.5055688356860482 + }, + { + "step": 2482, + "lr": 0.0001, + "sup_loss": 1.517113926530663 + }, + { + "step": 2483, + "lr": 0.0001, + "sup_loss": 1.4858444133314637 + }, + { + "step": 2484, + "lr": 0.0001, + "sup_loss": 1.4829619394794273 + }, + { + "step": 2485, + "lr": 0.0001, + "sup_loss": 1.5129960316707085 + }, + { + "step": 2486, + "lr": 0.0001, + "sup_loss": 1.5095375036371474 + }, + { + "step": 2487, + "lr": 0.0001, + "sup_loss": 1.51302862806255 + }, + { + "step": 2488, + "lr": 0.0001, + "sup_loss": 1.4990439940974882 + }, + { + "step": 2489, + "lr": 0.0001, + "sup_loss": 1.498911766899237 + }, + { + "step": 2490, + "lr": 0.0001, + "sup_loss": 1.5263156124129582 + }, + { + "step": 2491, + "lr": 0.0001, + "sup_loss": 1.503011740167487 + }, + { + "step": 2492, + "lr": 0.0001, + "sup_loss": 1.5196100153916334 + }, + { + "step": 2493, + "lr": 0.0001, + "sup_loss": 1.4996933628105287 + }, + { + "step": 2494, + "lr": 0.0001, + "sup_loss": 1.5061428932633767 + }, + { + "step": 2495, + "lr": 0.0001, + "sup_loss": 1.5087870371039427 + }, + { + "step": 2496, + "lr": 0.0001, + "sup_loss": 1.4756574804901088 + }, + { + "step": 2497, + "lr": 0.0001, + "sup_loss": 1.533409310497432 + }, + { + "step": 2498, + "lr": 0.0001, + "sup_loss": 1.526628489452307 + }, + { + "step": 2499, + "lr": 0.0001, + "sup_loss": 1.5095126140962092 + }, + { + "step": 2500, + "lr": 0.0001, + "sup_loss": 1.4692957090832033, + "lyap1_mean": -9.722370147705078, + "lyap1_max": -9.41787338256836, + "lyap_spec_mean": [ + -9.722370147705078, + -9.96712875366211 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2501, + "lr": 0.0001, + "sup_loss": 1.510262111319078 + }, + { + "step": 2502, + "lr": 0.0001, + "sup_loss": 1.5230026596832358 + }, + { + "step": 2503, + "lr": 0.0001, + "sup_loss": 1.5062160056737437 + }, + { + "step": 2504, + "lr": 0.0001, + "sup_loss": 1.5227650086320035 + }, + { + "step": 2505, + "lr": 0.0001, + "sup_loss": 1.4992936617462589 + }, + { + "step": 2506, + "lr": 0.0001, + "sup_loss": 1.4958924329884424 + }, + { + "step": 2507, + "lr": 0.0001, + "sup_loss": 1.5808081970424663 + }, + { + "step": 2508, + "lr": 0.0001, + "sup_loss": 1.5469868286277813 + }, + { + "step": 2509, + "lr": 0.0001, + "sup_loss": 1.516190061958228 + }, + { + "step": 2510, + "lr": 0.0001, + "sup_loss": 1.5097514377556505 + }, + { + "step": 2511, + "lr": 0.0001, + "sup_loss": 1.4987711329774644 + }, + { + "step": 2512, + "lr": 0.0001, + "sup_loss": 1.5083291933870986 + }, + { + "step": 2513, + "lr": 0.0001, + "sup_loss": 1.519182558049962 + }, + { + "step": 2514, + "lr": 0.0001, + "sup_loss": 1.4623807003654992 + }, + { + "step": 2515, + "lr": 0.0001, + "sup_loss": 1.5398037274907246 + }, + { + "step": 2516, + "lr": 0.0001, + "sup_loss": 1.567806095291083 + }, + { + "step": 2517, + "lr": 0.0001, + "sup_loss": 1.5105802578200227 + }, + { + "step": 2518, + "lr": 0.0001, + "sup_loss": 1.5103219979338325 + }, + { + "step": 2519, + "lr": 0.0001, + "sup_loss": 1.51267038814311 + }, + { + "step": 2520, + "lr": 0.0001, + "sup_loss": 1.499505087651394 + }, + { + "step": 2521, + "lr": 0.0001, + "sup_loss": 1.5430285995034094 + }, + { + "step": 2522, + "lr": 0.0001, + "sup_loss": 1.5364231161341577 + }, + { + "step": 2523, + "lr": 0.0001, + "sup_loss": 1.5192946873266093 + }, + { + "step": 2524, + "lr": 0.0001, + "sup_loss": 1.5400403931411057 + }, + { + "step": 2525, + "lr": 0.0001, + "sup_loss": 1.5086648406276169 + }, + { + "step": 2526, + "lr": 0.0001, + "sup_loss": 1.4892824260216686 + }, + { + "step": 2527, + "lr": 0.0001, + "sup_loss": 1.5053524916526004 + }, + { + "step": 2528, + "lr": 0.0001, + "sup_loss": 1.533691403831978 + }, + { + "step": 2529, + "lr": 0.0001, + "sup_loss": 1.4789377652148066 + }, + { + "step": 2530, + "lr": 0.0001, + "sup_loss": 1.5255096779748838 + }, + { + "step": 2531, + "lr": 0.0001, + "sup_loss": 1.5232084361583873 + }, + { + "step": 2532, + "lr": 0.0001, + "sup_loss": 1.4960780703934833 + }, + { + "step": 2533, + "lr": 0.0001, + "sup_loss": 1.5635575533962627 + }, + { + "step": 2534, + "lr": 0.0001, + "sup_loss": 1.5020074666882783 + }, + { + "step": 2535, + "lr": 0.0001, + "sup_loss": 1.512285491291703 + }, + { + "step": 2536, + "lr": 0.0001, + "sup_loss": 1.506302605835212 + }, + { + "step": 2537, + "lr": 0.0001, + "sup_loss": 1.5153734799882699 + }, + { + "step": 2538, + "lr": 0.0001, + "sup_loss": 1.4828358630743248 + }, + { + "step": 2539, + "lr": 0.0001, + "sup_loss": 1.5154986784693847 + }, + { + "step": 2540, + "lr": 0.0001, + "sup_loss": 1.5241497941485957 + }, + { + "step": 2541, + "lr": 0.0001, + "sup_loss": 1.4944323499384178 + }, + { + "step": 2542, + "lr": 0.0001, + "sup_loss": 1.515913681583083 + }, + { + "step": 2543, + "lr": 0.0001, + "sup_loss": 1.539751919082286 + }, + { + "step": 2544, + "lr": 0.0001, + "sup_loss": 1.4956286568088142 + }, + { + "step": 2545, + "lr": 0.0001, + "sup_loss": 1.543471056360199 + }, + { + "step": 2546, + "lr": 0.0001, + "sup_loss": 1.5122431319654748 + }, + { + "step": 2547, + "lr": 0.0001, + "sup_loss": 1.50866819272744 + }, + { + "step": 2548, + "lr": 0.0001, + "sup_loss": 1.526507136162483 + }, + { + "step": 2549, + "lr": 0.0001, + "sup_loss": 1.500080639101608 + }, + { + "step": 2550, + "lr": 0.0001, + "sup_loss": 1.5170604055313779, + "lyap1_mean": -9.317399978637695, + "lyap1_max": -9.03246021270752, + "lyap_spec_mean": [ + -9.317399978637695, + -9.842851638793945 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2551, + "lr": 0.0001, + "sup_loss": 1.5399264638261092 + }, + { + "step": 2552, + "lr": 0.0001, + "sup_loss": 1.5012167197508801 + }, + { + "step": 2553, + "lr": 0.0001, + "sup_loss": 1.5294229657422962 + }, + { + "step": 2554, + "lr": 0.0001, + "sup_loss": 1.5101706520897022 + }, + { + "step": 2555, + "lr": 0.0001, + "sup_loss": 1.5328054296714517 + }, + { + "step": 2556, + "lr": 0.0001, + "sup_loss": 1.4730081523393925 + }, + { + "step": 2557, + "lr": 0.0001, + "sup_loss": 1.533290285328427 + }, + { + "step": 2558, + "lr": 0.0001, + "sup_loss": 1.5221956528916951 + }, + { + "step": 2559, + "lr": 0.0001, + "sup_loss": 1.4617224536203008 + }, + { + "step": 2560, + "lr": 0.0001, + "sup_loss": 1.536071138683555 + }, + { + "step": 2561, + "lr": 0.0001, + "sup_loss": 1.536126142290018 + }, + { + "step": 2562, + "lr": 0.0001, + "sup_loss": 1.5359590820875841 + }, + { + "step": 2563, + "lr": 0.0001, + "sup_loss": 1.5165739867994446 + }, + { + "step": 2564, + "lr": 0.0001, + "sup_loss": 1.5128932027320208 + }, + { + "step": 2565, + "lr": 0.0001, + "sup_loss": 1.5097098904152302 + }, + { + "step": 2566, + "lr": 0.0001, + "sup_loss": 1.5164607687239908 + }, + { + "step": 2567, + "lr": 0.0001, + "sup_loss": 1.5256818527959086 + }, + { + "step": 2568, + "lr": 0.0001, + "sup_loss": 1.5268477262292575 + }, + { + "step": 2569, + "lr": 0.0001, + "sup_loss": 1.5052210001119053 + }, + { + "step": 2570, + "lr": 0.0001, + "sup_loss": 1.5368654769590966 + }, + { + "step": 2571, + "lr": 0.0001, + "sup_loss": 1.5328029352225652 + }, + { + "step": 2572, + "lr": 0.0001, + "sup_loss": 1.5161923486269344 + }, + { + "step": 2573, + "lr": 0.0001, + "sup_loss": 1.523740627599565 + }, + { + "step": 2574, + "lr": 0.0001, + "sup_loss": 1.5326466414504234 + }, + { + "step": 2575, + "lr": 0.0001, + "sup_loss": 1.5264800995523942 + }, + { + "step": 2576, + "lr": 0.0001, + "sup_loss": 1.5157052547153635 + }, + { + "step": 2577, + "lr": 0.0001, + "sup_loss": 1.5061953992885402 + }, + { + "step": 2578, + "lr": 0.0001, + "sup_loss": 1.4718647984270186 + }, + { + "step": 2579, + "lr": 0.0001, + "sup_loss": 1.5056637509891666 + }, + { + "step": 2580, + "lr": 0.0001, + "sup_loss": 1.5231152022458867 + }, + { + "step": 2581, + "lr": 0.0001, + "sup_loss": 1.472045774542771 + }, + { + "step": 2582, + "lr": 0.0001, + "sup_loss": 1.523225945832038 + }, + { + "step": 2583, + "lr": 0.0001, + "sup_loss": 1.519330094290661 + }, + { + "step": 2584, + "lr": 0.0001, + "sup_loss": 1.5124375471792433 + }, + { + "step": 2585, + "lr": 0.0001, + "sup_loss": 1.4920325297469896 + }, + { + "step": 2586, + "lr": 0.0001, + "sup_loss": 1.5197706067483658 + }, + { + "step": 2587, + "lr": 0.0001, + "sup_loss": 1.5196078796330557 + }, + { + "step": 2588, + "lr": 0.0001, + "sup_loss": 1.5299211213481492 + }, + { + "step": 2589, + "lr": 0.0001, + "sup_loss": 1.5342026729500806 + }, + { + "step": 2590, + "lr": 0.0001, + "sup_loss": 1.5292051015646242 + }, + { + "step": 2591, + "lr": 0.0001, + "sup_loss": 1.5233060448734654 + }, + { + "step": 2592, + "lr": 0.0001, + "sup_loss": 1.5093039230492684 + }, + { + "step": 2593, + "lr": 0.0001, + "sup_loss": 1.5128851723151044 + }, + { + "step": 2594, + "lr": 0.0001, + "sup_loss": 1.5664569364485283 + }, + { + "step": 2595, + "lr": 0.0001, + "sup_loss": 1.5030621194535925 + }, + { + "step": 2596, + "lr": 0.0001, + "sup_loss": 1.5165761029305034 + }, + { + "step": 2597, + "lr": 0.0001, + "sup_loss": 1.4718632136686767 + }, + { + "step": 2598, + "lr": 0.0001, + "sup_loss": 1.5329459624819217 + }, + { + "step": 2599, + "lr": 0.0001, + "sup_loss": 1.4783265813478381 + }, + { + "step": 2600, + "lr": 0.0001, + "sup_loss": 1.522460607289816, + "lyap1_mean": -8.991159439086914, + "lyap1_max": -8.744073867797852, + "lyap_spec_mean": [ + -8.991159439086914, + -9.460504531860352 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2601, + "lr": 0.0001, + "sup_loss": 1.513709520704918 + }, + { + "step": 2602, + "lr": 0.0001, + "sup_loss": 1.519574663146122 + }, + { + "step": 2603, + "lr": 0.0001, + "sup_loss": 1.4793081273994813 + }, + { + "step": 2604, + "lr": 0.0001, + "sup_loss": 1.5166396505311537 + }, + { + "step": 2605, + "lr": 0.0001, + "sup_loss": 1.5262304129759412 + }, + { + "step": 2606, + "lr": 0.0001, + "sup_loss": 1.509487326807982 + }, + { + "step": 2607, + "lr": 0.0001, + "sup_loss": 1.498855072444536 + }, + { + "step": 2608, + "lr": 0.0001, + "sup_loss": 1.5192958816113644 + }, + { + "step": 2609, + "lr": 0.0001, + "sup_loss": 1.536362258231005 + }, + { + "step": 2610, + "lr": 0.0001, + "sup_loss": 1.512563608174647 + }, + { + "step": 2611, + "lr": 0.0001, + "sup_loss": 1.5056413268592939 + }, + { + "step": 2612, + "lr": 0.0001, + "sup_loss": 1.5254944142628453 + }, + { + "step": 2613, + "lr": 0.0001, + "sup_loss": 1.5140763550911684 + }, + { + "step": 2614, + "lr": 0.0001, + "sup_loss": 1.553554040273379 + }, + { + "step": 2615, + "lr": 0.0001, + "sup_loss": 1.5310854511907914 + }, + { + "step": 2616, + "lr": 0.0001, + "sup_loss": 1.5228728861415244 + }, + { + "step": 2617, + "lr": 0.0001, + "sup_loss": 1.5534644742002843 + }, + { + "step": 2618, + "lr": 0.0001, + "sup_loss": 1.509831921066496 + }, + { + "step": 2619, + "lr": 0.0001, + "sup_loss": 1.4731662329622577 + }, + { + "step": 2620, + "lr": 0.0001, + "sup_loss": 1.5032760936853962 + }, + { + "step": 2621, + "lr": 0.0001, + "sup_loss": 1.5022822352343392 + }, + { + "step": 2622, + "lr": 0.0001, + "sup_loss": 1.509767442894029 + }, + { + "step": 2623, + "lr": 0.0001, + "sup_loss": 1.539584929620361 + }, + { + "step": 2624, + "lr": 0.0001, + "sup_loss": 1.485557364246572 + }, + { + "step": 2625, + "lr": 0.0001, + "sup_loss": 1.5291985753793669 + }, + { + "step": 2626, + "lr": 0.0001, + "sup_loss": 1.512564072496864 + }, + { + "step": 2627, + "lr": 0.0001, + "sup_loss": 1.5091088086458724 + }, + { + "step": 2628, + "lr": 0.0001, + "sup_loss": 1.5196193330892542 + }, + { + "step": 2629, + "lr": 0.0001, + "sup_loss": 1.5092906848718086 + }, + { + "step": 2630, + "lr": 0.0001, + "sup_loss": 1.5125099635248638 + }, + { + "step": 2631, + "lr": 0.0001, + "sup_loss": 1.4894883259769662 + }, + { + "step": 2632, + "lr": 0.0001, + "sup_loss": 1.5260278607951618 + }, + { + "step": 2633, + "lr": 0.0001, + "sup_loss": 1.5061989749466524 + }, + { + "step": 2634, + "lr": 0.0001, + "sup_loss": 1.5292719087959754 + }, + { + "step": 2635, + "lr": 0.0001, + "sup_loss": 1.529458637848503 + }, + { + "step": 2636, + "lr": 0.0001, + "sup_loss": 1.5090783837095563 + }, + { + "step": 2637, + "lr": 0.0001, + "sup_loss": 1.5202244762918657 + }, + { + "step": 2638, + "lr": 0.0001, + "sup_loss": 1.486308963677409 + }, + { + "step": 2639, + "lr": 0.0001, + "sup_loss": 1.5257988671279712 + }, + { + "step": 2640, + "lr": 0.0001, + "sup_loss": 1.5334120435709575 + }, + { + "step": 2641, + "lr": 0.0001, + "sup_loss": 1.5156536372448544 + }, + { + "step": 2642, + "lr": 0.0001, + "sup_loss": 1.5033093386679923 + }, + { + "step": 2643, + "lr": 0.0001, + "sup_loss": 1.506277115915865 + }, + { + "step": 2644, + "lr": 0.0001, + "sup_loss": 1.5055643633697788 + }, + { + "step": 2645, + "lr": 0.0001, + "sup_loss": 1.5090272047362152 + }, + { + "step": 2646, + "lr": 0.0001, + "sup_loss": 1.5203353498544592 + }, + { + "step": 2647, + "lr": 0.0001, + "sup_loss": 1.5128209003562914 + }, + { + "step": 2648, + "lr": 0.0001, + "sup_loss": 1.502168380136078 + }, + { + "step": 2649, + "lr": 0.0001, + "sup_loss": 1.4885951784459548 + }, + { + "step": 2650, + "lr": 0.0001, + "sup_loss": 1.5664356958963812, + "lyap1_mean": -9.098038673400879, + "lyap1_max": -8.691319465637207, + "lyap_spec_mean": [ + -9.098038673400879, + -9.524681091308594 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2651, + "lr": 0.0001, + "sup_loss": 1.50955000063896 + }, + { + "step": 2652, + "lr": 0.0001, + "sup_loss": 1.4717415574921446 + }, + { + "step": 2653, + "lr": 0.0001, + "sup_loss": 1.5367500951782844 + }, + { + "step": 2654, + "lr": 0.0001, + "sup_loss": 1.5260445396284146 + }, + { + "step": 2655, + "lr": 0.0001, + "sup_loss": 1.5261448852044486 + }, + { + "step": 2656, + "lr": 0.0001, + "sup_loss": 1.4955761197098019 + }, + { + "step": 2657, + "lr": 0.0001, + "sup_loss": 1.5294141840450874 + }, + { + "step": 2658, + "lr": 0.0001, + "sup_loss": 1.5299417610800812 + }, + { + "step": 2659, + "lr": 0.0001, + "sup_loss": 1.5405678741024642 + }, + { + "step": 2660, + "lr": 0.0001, + "sup_loss": 1.5228389818462775 + }, + { + "step": 2661, + "lr": 0.0001, + "sup_loss": 1.5365715263143482 + }, + { + "step": 2662, + "lr": 0.0001, + "sup_loss": 1.5254532679990822 + }, + { + "step": 2663, + "lr": 0.0001, + "sup_loss": 1.4966829653699867 + }, + { + "step": 2664, + "lr": 0.0001, + "sup_loss": 1.5204010555508092 + }, + { + "step": 2665, + "lr": 0.0001, + "sup_loss": 1.5273416981132724 + }, + { + "step": 2666, + "lr": 0.0001, + "sup_loss": 1.5116567801316738 + }, + { + "step": 2667, + "lr": 0.0001, + "sup_loss": 1.5093335139208048 + }, + { + "step": 2668, + "lr": 0.0001, + "sup_loss": 1.5230042167545836 + }, + { + "step": 2669, + "lr": 0.0001, + "sup_loss": 1.4986313228013266 + }, + { + "step": 2670, + "lr": 0.0001, + "sup_loss": 1.557162555559087 + }, + { + "step": 2671, + "lr": 0.0001, + "sup_loss": 1.4786506212723804 + }, + { + "step": 2672, + "lr": 0.0001, + "sup_loss": 1.5050489084823298 + }, + { + "step": 2673, + "lr": 0.0001, + "sup_loss": 1.4960961300252504 + }, + { + "step": 2674, + "lr": 0.0001, + "sup_loss": 1.5066087972348843 + }, + { + "step": 2675, + "lr": 0.0001, + "sup_loss": 1.502849133584328 + }, + { + "step": 2676, + "lr": 0.0001, + "sup_loss": 1.491399637414021 + }, + { + "step": 2677, + "lr": 0.0001, + "sup_loss": 1.4748144293147665 + }, + { + "step": 2678, + "lr": 0.0001, + "sup_loss": 1.5222502156013302 + }, + { + "step": 2679, + "lr": 0.0001, + "sup_loss": 1.5333073402187491 + }, + { + "step": 2680, + "lr": 0.0001, + "sup_loss": 1.4788505444389035 + }, + { + "step": 2681, + "lr": 0.0001, + "sup_loss": 1.5123469915147372 + }, + { + "step": 2682, + "lr": 0.0001, + "sup_loss": 1.5539607026766038 + }, + { + "step": 2683, + "lr": 0.0001, + "sup_loss": 1.5225917848753152 + }, + { + "step": 2684, + "lr": 0.0001, + "sup_loss": 1.5292863224278475 + }, + { + "step": 2685, + "lr": 0.0001, + "sup_loss": 1.4653128830528495 + }, + { + "step": 2686, + "lr": 0.0001, + "sup_loss": 1.5226305139501877 + }, + { + "step": 2687, + "lr": 0.0001, + "sup_loss": 1.516397521042111 + }, + { + "step": 2688, + "lr": 0.0001, + "sup_loss": 1.5225587311428224 + }, + { + "step": 2689, + "lr": 0.0001, + "sup_loss": 1.485874156432889 + }, + { + "step": 2690, + "lr": 0.0001, + "sup_loss": 1.525788864259511 + }, + { + "step": 2691, + "lr": 0.0001, + "sup_loss": 1.49173254918763 + }, + { + "step": 2692, + "lr": 0.0001, + "sup_loss": 1.5203391479262613 + }, + { + "step": 2693, + "lr": 0.0001, + "sup_loss": 1.5169403219550637 + }, + { + "step": 2694, + "lr": 0.0001, + "sup_loss": 1.5165502458311366 + }, + { + "step": 2695, + "lr": 0.0001, + "sup_loss": 1.478538283995527 + }, + { + "step": 2696, + "lr": 0.0001, + "sup_loss": 1.5230183640172874 + }, + { + "step": 2697, + "lr": 0.0001, + "sup_loss": 1.512077343780804 + }, + { + "step": 2698, + "lr": 0.0001, + "sup_loss": 1.5202414725389846 + }, + { + "step": 2699, + "lr": 0.0001, + "sup_loss": 1.4989056642254428 + }, + { + "step": 2700, + "lr": 0.0001, + "sup_loss": 1.503270026100708, + "lyap1_mean": -8.844300270080566, + "lyap1_max": -8.456679344177246, + "lyap_spec_mean": [ + -8.84429931640625, + -9.363276481628418 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2701, + "lr": 0.0001, + "sup_loss": 1.5511265684401838 + }, + { + "step": 2702, + "lr": 0.0001, + "sup_loss": 1.496178695498028 + }, + { + "step": 2703, + "lr": 0.0001, + "sup_loss": 1.5161816542247941 + }, + { + "step": 2704, + "lr": 0.0001, + "sup_loss": 1.47465630106748 + }, + { + "step": 2705, + "lr": 0.0001, + "sup_loss": 1.5172439988453095 + }, + { + "step": 2706, + "lr": 0.0001, + "sup_loss": 1.5642189851624408 + }, + { + "step": 2707, + "lr": 0.0001, + "sup_loss": 1.4915071939342264 + }, + { + "step": 2708, + "lr": 0.0001, + "sup_loss": 1.4675037944286573 + }, + { + "step": 2709, + "lr": 0.0001, + "sup_loss": 1.5180271981823568 + }, + { + "step": 2710, + "lr": 0.0001, + "sup_loss": 1.5295331042799312 + }, + { + "step": 2711, + "lr": 0.0001, + "sup_loss": 1.4858501731187082 + }, + { + "step": 2712, + "lr": 0.0001, + "sup_loss": 1.5092818766602714 + }, + { + "step": 2713, + "lr": 0.0001, + "sup_loss": 1.5437786837026561 + }, + { + "step": 2714, + "lr": 0.0001, + "sup_loss": 1.4791228174298992 + }, + { + "step": 2715, + "lr": 0.0001, + "sup_loss": 1.5167261903103724 + }, + { + "step": 2716, + "lr": 0.0001, + "sup_loss": 1.4861472711577466 + }, + { + "step": 2717, + "lr": 0.0001, + "sup_loss": 1.4550381333339022 + }, + { + "step": 2718, + "lr": 0.0001, + "sup_loss": 1.4798206462223722 + }, + { + "step": 2719, + "lr": 0.0001, + "sup_loss": 1.5233225019624146 + }, + { + "step": 2720, + "lr": 0.0001, + "sup_loss": 1.5013551993922651 + }, + { + "step": 2721, + "lr": 0.0001, + "sup_loss": 1.490292793753297 + }, + { + "step": 2722, + "lr": 0.0001, + "sup_loss": 1.5034008503801666 + }, + { + "step": 2723, + "lr": 0.0001, + "sup_loss": 1.5156252395962095 + }, + { + "step": 2724, + "lr": 0.0001, + "sup_loss": 1.5165280950357019 + }, + { + "step": 2725, + "lr": 0.0001, + "sup_loss": 1.51380026303828 + }, + { + "step": 2726, + "lr": 0.0001, + "sup_loss": 1.5233494082140948 + }, + { + "step": 2727, + "lr": 0.0001, + "sup_loss": 1.5361127730854214 + }, + { + "step": 2728, + "lr": 0.0001, + "sup_loss": 1.529585195212748 + }, + { + "step": 2729, + "lr": 0.0001, + "sup_loss": 1.5333029699122303 + }, + { + "step": 2730, + "lr": 0.0001, + "sup_loss": 1.4760620606899622 + }, + { + "step": 2731, + "lr": 0.0001, + "sup_loss": 1.5102922271962909 + }, + { + "step": 2732, + "lr": 0.0001, + "sup_loss": 1.5197986858506476 + }, + { + "step": 2733, + "lr": 0.0001, + "sup_loss": 1.465352990720544 + }, + { + "step": 2734, + "lr": 0.0001, + "sup_loss": 1.5368086985238252 + }, + { + "step": 2735, + "lr": 0.0001, + "sup_loss": 1.4992165062942173 + }, + { + "step": 2736, + "lr": 0.0001, + "sup_loss": 1.4619453770721311 + }, + { + "step": 2737, + "lr": 0.0001, + "sup_loss": 1.5200619629235568 + }, + { + "step": 2738, + "lr": 0.0001, + "sup_loss": 1.5191772522541331 + }, + { + "step": 2739, + "lr": 0.0001, + "sup_loss": 1.5197210237629692 + }, + { + "step": 2740, + "lr": 0.0001, + "sup_loss": 1.5022190437708847 + }, + { + "step": 2741, + "lr": 0.0001, + "sup_loss": 1.5021194751646962 + }, + { + "step": 2742, + "lr": 0.0001, + "sup_loss": 1.5194594023036427 + }, + { + "step": 2743, + "lr": 0.0001, + "sup_loss": 1.5557393145786977 + }, + { + "step": 2744, + "lr": 0.0001, + "sup_loss": 1.4853784294279608 + }, + { + "step": 2745, + "lr": 0.0001, + "sup_loss": 1.5059164155983562 + }, + { + "step": 2746, + "lr": 0.0001, + "sup_loss": 1.5071862003081726 + }, + { + "step": 2747, + "lr": 0.0001, + "sup_loss": 1.5054158872089871 + }, + { + "step": 2748, + "lr": 0.0001, + "sup_loss": 1.5287817218840454 + }, + { + "step": 2749, + "lr": 0.0001, + "sup_loss": 1.52287964149721 + }, + { + "step": 2750, + "lr": 0.0001, + "sup_loss": 1.519570167029896, + "lyap1_mean": -8.801053047180176, + "lyap1_max": -8.30211353302002, + "lyap_spec_mean": [ + -8.801053047180176, + -9.077676773071289 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2751, + "lr": 0.0001, + "sup_loss": 1.5648772178389727 + }, + { + "step": 2752, + "lr": 0.0001, + "sup_loss": 1.529638673055108 + }, + { + "step": 2753, + "lr": 0.0001, + "sup_loss": 1.5071772280277125 + }, + { + "step": 2754, + "lr": 0.0001, + "sup_loss": 1.5223091943461458 + }, + { + "step": 2755, + "lr": 0.0001, + "sup_loss": 1.5227720065853825 + }, + { + "step": 2756, + "lr": 0.0001, + "sup_loss": 1.546720220781803 + }, + { + "step": 2757, + "lr": 0.0001, + "sup_loss": 1.539895998969467 + }, + { + "step": 2758, + "lr": 0.0001, + "sup_loss": 1.5159287627241147 + }, + { + "step": 2759, + "lr": 0.0001, + "sup_loss": 1.5227834110793024 + }, + { + "step": 2760, + "lr": 0.0001, + "sup_loss": 1.5164726453766308 + }, + { + "step": 2761, + "lr": 0.0001, + "sup_loss": 1.520064355764943 + }, + { + "step": 2762, + "lr": 0.0001, + "sup_loss": 1.5129681788510891 + }, + { + "step": 2763, + "lr": 0.0001, + "sup_loss": 1.5216407146223823 + }, + { + "step": 2764, + "lr": 0.0001, + "sup_loss": 1.5059002676474547 + }, + { + "step": 2765, + "lr": 0.0001, + "sup_loss": 1.5303910916639902 + }, + { + "step": 2766, + "lr": 0.0001, + "sup_loss": 1.510413250591205 + }, + { + "step": 2767, + "lr": 0.0001, + "sup_loss": 1.4913779043178759 + }, + { + "step": 2768, + "lr": 0.0001, + "sup_loss": 1.4922259513098997 + }, + { + "step": 2769, + "lr": 0.0001, + "sup_loss": 1.5133804967369255 + }, + { + "step": 2770, + "lr": 0.0001, + "sup_loss": 1.523161164391776 + }, + { + "step": 2771, + "lr": 0.0001, + "sup_loss": 1.4889301465985891 + }, + { + "step": 2772, + "lr": 0.0001, + "sup_loss": 1.5032979324683462 + }, + { + "step": 2773, + "lr": 0.0001, + "sup_loss": 1.5028887733982845 + }, + { + "step": 2774, + "lr": 0.0001, + "sup_loss": 1.4822812000183059 + }, + { + "step": 2775, + "lr": 0.0001, + "sup_loss": 1.5157968841858014 + }, + { + "step": 2776, + "lr": 0.0001, + "sup_loss": 1.5156942405858151 + }, + { + "step": 2777, + "lr": 0.0001, + "sup_loss": 1.5134349276354253 + }, + { + "step": 2778, + "lr": 0.0001, + "sup_loss": 1.5122486282937702 + }, + { + "step": 2779, + "lr": 0.0001, + "sup_loss": 1.505506066495928 + }, + { + "step": 2780, + "lr": 0.0001, + "sup_loss": 1.5097667302829454 + }, + { + "step": 2781, + "lr": 0.0001, + "sup_loss": 1.5466109733958 + }, + { + "step": 2782, + "lr": 0.0001, + "sup_loss": 1.525759811657514 + }, + { + "step": 2783, + "lr": 0.0001, + "sup_loss": 1.5128629637064905 + }, + { + "step": 2784, + "lr": 0.0001, + "sup_loss": 1.5198994957125693 + }, + { + "step": 2785, + "lr": 0.0001, + "sup_loss": 1.5035589489587708 + }, + { + "step": 2786, + "lr": 0.0001, + "sup_loss": 1.5187978238735993 + }, + { + "step": 2787, + "lr": 0.0001, + "sup_loss": 1.5195311138890102 + }, + { + "step": 2788, + "lr": 0.0001, + "sup_loss": 1.5205281794857617 + }, + { + "step": 2789, + "lr": 0.0001, + "sup_loss": 1.532671251979135 + }, + { + "step": 2790, + "lr": 0.0001, + "sup_loss": 1.4914008687504563 + }, + { + "step": 2791, + "lr": 0.0001, + "sup_loss": 1.5154638737532353 + }, + { + "step": 2792, + "lr": 0.0001, + "sup_loss": 1.5131350673844843 + }, + { + "step": 2793, + "lr": 0.0001, + "sup_loss": 1.5504697866490342 + }, + { + "step": 2794, + "lr": 0.0001, + "sup_loss": 1.4917874243325049 + }, + { + "step": 2795, + "lr": 0.0001, + "sup_loss": 1.4952973445724187 + }, + { + "step": 2796, + "lr": 0.0001, + "sup_loss": 1.5428367076020102 + }, + { + "step": 2797, + "lr": 0.0001, + "sup_loss": 1.5029142310687524 + }, + { + "step": 2798, + "lr": 0.0001, + "sup_loss": 1.5027768002197344 + }, + { + "step": 2799, + "lr": 0.0001, + "sup_loss": 1.525199428026072 + }, + { + "step": 2800, + "lr": 0.0001, + "sup_loss": 1.5036956062620364, + "lyap1_mean": -8.647153854370117, + "lyap1_max": -8.188324928283691, + "lyap_spec_mean": [ + -8.647153854370117, + -8.997187614440918 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2801, + "lr": 0.0001, + "sup_loss": 1.5125319335219325 + }, + { + "step": 2802, + "lr": 0.0001, + "sup_loss": 1.536798703561956 + }, + { + "step": 2803, + "lr": 0.0001, + "sup_loss": 1.5270352546818193 + }, + { + "step": 2804, + "lr": 0.0001, + "sup_loss": 1.5093320098705818 + }, + { + "step": 2805, + "lr": 0.0001, + "sup_loss": 1.5121010366631968 + }, + { + "step": 2806, + "lr": 0.0001, + "sup_loss": 1.5063748400811245 + }, + { + "step": 2807, + "lr": 0.0001, + "sup_loss": 1.4926463518448558 + }, + { + "step": 2808, + "lr": 0.0001, + "sup_loss": 1.5222635299887906 + }, + { + "step": 2809, + "lr": 0.0001, + "sup_loss": 1.5196007524154864 + }, + { + "step": 2810, + "lr": 0.0001, + "sup_loss": 1.4685719139699192 + }, + { + "step": 2811, + "lr": 0.0001, + "sup_loss": 1.513006219285594 + }, + { + "step": 2812, + "lr": 0.0001, + "sup_loss": 1.5058657970002711 + }, + { + "step": 2813, + "lr": 0.0001, + "sup_loss": 1.536746902168418 + }, + { + "step": 2814, + "lr": 0.0001, + "sup_loss": 1.5406282119224333 + }, + { + "step": 2815, + "lr": 0.0001, + "sup_loss": 1.543025434044132 + }, + { + "step": 2816, + "lr": 0.0001, + "sup_loss": 1.5159381635868443 + }, + { + "step": 2817, + "lr": 0.0001, + "sup_loss": 1.4823734967893416 + }, + { + "step": 2818, + "lr": 0.0001, + "sup_loss": 1.5200737038741685 + }, + { + "step": 2819, + "lr": 0.0001, + "sup_loss": 1.4849751893471115 + }, + { + "step": 2820, + "lr": 0.0001, + "sup_loss": 1.4786483002851005 + }, + { + "step": 2821, + "lr": 0.0001, + "sup_loss": 1.5155737415749557 + }, + { + "step": 2822, + "lr": 0.0001, + "sup_loss": 1.4953605064801585 + }, + { + "step": 2823, + "lr": 0.0001, + "sup_loss": 1.5118310323333173 + }, + { + "step": 2824, + "lr": 0.0001, + "sup_loss": 1.5195909275395412 + }, + { + "step": 2825, + "lr": 0.0001, + "sup_loss": 1.5125435612065279 + }, + { + "step": 2826, + "lr": 0.0001, + "sup_loss": 1.5241681170172385 + }, + { + "step": 2827, + "lr": 0.0001, + "sup_loss": 1.5064338562751745 + }, + { + "step": 2828, + "lr": 0.0001, + "sup_loss": 1.5401501624399148 + }, + { + "step": 2829, + "lr": 0.0001, + "sup_loss": 1.5294878845098578 + }, + { + "step": 2830, + "lr": 0.0001, + "sup_loss": 1.5566006121620992 + }, + { + "step": 2831, + "lr": 0.0001, + "sup_loss": 1.5094978870905893 + }, + { + "step": 2832, + "lr": 0.0001, + "sup_loss": 1.515939122423795 + }, + { + "step": 2833, + "lr": 0.0001, + "sup_loss": 1.4450042525661697 + }, + { + "step": 2834, + "lr": 0.0001, + "sup_loss": 1.5389337114877 + }, + { + "step": 2835, + "lr": 0.0001, + "sup_loss": 1.5294279329757006 + }, + { + "step": 2836, + "lr": 0.0001, + "sup_loss": 1.5261040021351397 + }, + { + "step": 2837, + "lr": 0.0001, + "sup_loss": 1.4959451720303794 + }, + { + "step": 2838, + "lr": 0.0001, + "sup_loss": 1.519141386246575 + }, + { + "step": 2839, + "lr": 0.0001, + "sup_loss": 1.5306672707465416 + }, + { + "step": 2840, + "lr": 0.0001, + "sup_loss": 1.4715441795933601 + }, + { + "step": 2841, + "lr": 0.0001, + "sup_loss": 1.51421525343719 + }, + { + "step": 2842, + "lr": 0.0001, + "sup_loss": 1.4998419003085695 + }, + { + "step": 2843, + "lr": 0.0001, + "sup_loss": 1.5102054783048908 + }, + { + "step": 2844, + "lr": 0.0001, + "sup_loss": 1.4929760453318592 + }, + { + "step": 2845, + "lr": 0.0001, + "sup_loss": 1.5255189625601524 + }, + { + "step": 2846, + "lr": 0.0001, + "sup_loss": 1.5154987556861856 + }, + { + "step": 2847, + "lr": 0.0001, + "sup_loss": 1.5228836117923434 + }, + { + "step": 2848, + "lr": 0.0001, + "sup_loss": 1.4724714266123842 + }, + { + "step": 2849, + "lr": 0.0001, + "sup_loss": 1.5265474599474491 + }, + { + "step": 2850, + "lr": 0.0001, + "sup_loss": 1.5028711815294737, + "lyap1_mean": -8.510161399841309, + "lyap1_max": -8.17573356628418, + "lyap_spec_mean": [ + -8.510161399841309, + -8.969608306884766 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2851, + "lr": 0.0001, + "sup_loss": 1.5234024222032492 + }, + { + "step": 2852, + "lr": 0.0001, + "sup_loss": 1.4960135853150378 + }, + { + "step": 2853, + "lr": 0.0001, + "sup_loss": 1.5020587539706471 + }, + { + "step": 2854, + "lr": 0.0001, + "sup_loss": 1.5094316912144357 + }, + { + "step": 2855, + "lr": 0.0001, + "sup_loss": 1.515735374973473 + }, + { + "step": 2856, + "lr": 0.0001, + "sup_loss": 1.5058923555680976 + }, + { + "step": 2857, + "lr": 0.0001, + "sup_loss": 1.4893797030103386 + }, + { + "step": 2858, + "lr": 0.0001, + "sup_loss": 1.5024567144183445 + }, + { + "step": 2859, + "lr": 0.0001, + "sup_loss": 1.5057054325436643 + }, + { + "step": 2860, + "lr": 0.0001, + "sup_loss": 1.4988336535578017 + }, + { + "step": 2861, + "lr": 0.0001, + "sup_loss": 1.5195141471820277 + }, + { + "step": 2862, + "lr": 0.0001, + "sup_loss": 1.529392168586038 + }, + { + "step": 2863, + "lr": 0.0001, + "sup_loss": 1.4993483419961429 + }, + { + "step": 2864, + "lr": 0.0001, + "sup_loss": 1.492027187369517 + }, + { + "step": 2865, + "lr": 0.0001, + "sup_loss": 1.4929064812776305 + }, + { + "step": 2866, + "lr": 0.0001, + "sup_loss": 1.4752352485826092 + }, + { + "step": 2867, + "lr": 0.0001, + "sup_loss": 1.4920797443792415 + }, + { + "step": 2868, + "lr": 0.0001, + "sup_loss": 1.5128688763599583 + }, + { + "step": 2869, + "lr": 0.0001, + "sup_loss": 1.5129956995865552 + }, + { + "step": 2870, + "lr": 0.0001, + "sup_loss": 1.4947422679864075 + }, + { + "step": 2871, + "lr": 0.0001, + "sup_loss": 1.4777502482068485 + }, + { + "step": 2872, + "lr": 0.0001, + "sup_loss": 1.4915466439356178 + }, + { + "step": 2873, + "lr": 0.0001, + "sup_loss": 1.5242733029185058 + }, + { + "step": 2874, + "lr": 0.0001, + "sup_loss": 1.5020832743061363 + }, + { + "step": 2875, + "lr": 0.0001, + "sup_loss": 1.5048972016688476 + }, + { + "step": 2876, + "lr": 0.0001, + "sup_loss": 1.526396347262128 + }, + { + "step": 2877, + "lr": 0.0001, + "sup_loss": 1.502344779491286 + }, + { + "step": 2878, + "lr": 0.0001, + "sup_loss": 1.501634727514593 + }, + { + "step": 2879, + "lr": 0.0001, + "sup_loss": 1.5127440180146767 + }, + { + "step": 2880, + "lr": 0.0001, + "sup_loss": 1.5183600202867316 + }, + { + "step": 2881, + "lr": 0.0001, + "sup_loss": 1.4646491099028862 + }, + { + "step": 2882, + "lr": 0.0001, + "sup_loss": 1.4888619742181834 + }, + { + "step": 2883, + "lr": 0.0001, + "sup_loss": 1.5197844238237044 + }, + { + "step": 2884, + "lr": 0.0001, + "sup_loss": 1.5148258113567532 + }, + { + "step": 2885, + "lr": 0.0001, + "sup_loss": 1.526741217416653 + }, + { + "step": 2886, + "lr": 0.0001, + "sup_loss": 1.5344325680979907 + }, + { + "step": 2887, + "lr": 0.0001, + "sup_loss": 1.5255962405794246 + }, + { + "step": 2888, + "lr": 0.0001, + "sup_loss": 1.4283915366452984 + }, + { + "step": 2889, + "lr": 0.0001, + "sup_loss": 1.5642760048597628 + }, + { + "step": 2890, + "lr": 0.0001, + "sup_loss": 1.509425604770576 + }, + { + "step": 2891, + "lr": 0.0001, + "sup_loss": 1.502933126099108 + }, + { + "step": 2892, + "lr": 0.0001, + "sup_loss": 1.5323946468570544 + }, + { + "step": 2893, + "lr": 0.0001, + "sup_loss": 1.4961967406226557 + }, + { + "step": 2894, + "lr": 0.0001, + "sup_loss": 1.5228417811556239 + }, + { + "step": 2895, + "lr": 0.0001, + "sup_loss": 1.5017764558613587 + }, + { + "step": 2896, + "lr": 0.0001, + "sup_loss": 1.5479284954456762 + }, + { + "step": 2897, + "lr": 0.0001, + "sup_loss": 1.5608331307208607 + }, + { + "step": 2898, + "lr": 0.0001, + "sup_loss": 1.4750939469143403 + }, + { + "step": 2899, + "lr": 0.0001, + "sup_loss": 1.5034357566166165 + }, + { + "step": 2900, + "lr": 0.0001, + "sup_loss": 1.520083346557646, + "lyap1_mean": -8.383435249328613, + "lyap1_max": -7.955485820770264, + "lyap_spec_mean": [ + -8.383434295654297, + -8.940679550170898 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2901, + "lr": 0.0001, + "sup_loss": 1.5048681559634283 + }, + { + "step": 2902, + "lr": 0.0001, + "sup_loss": 1.5469485154274079 + }, + { + "step": 2903, + "lr": 0.0001, + "sup_loss": 1.5231801932115687 + }, + { + "step": 2904, + "lr": 0.0001, + "sup_loss": 1.5025013103811191 + }, + { + "step": 2905, + "lr": 0.0001, + "sup_loss": 1.4819126653875458 + }, + { + "step": 2906, + "lr": 0.0001, + "sup_loss": 1.4844672403032206 + }, + { + "step": 2907, + "lr": 0.0001, + "sup_loss": 1.5496275885969282 + }, + { + "step": 2908, + "lr": 0.0001, + "sup_loss": 1.5255158989015356 + }, + { + "step": 2909, + "lr": 0.0001, + "sup_loss": 1.5133561320405389 + }, + { + "step": 2910, + "lr": 0.0001, + "sup_loss": 1.5091299354077576 + }, + { + "step": 2911, + "lr": 0.0001, + "sup_loss": 1.5133633245472407 + }, + { + "step": 2912, + "lr": 0.0001, + "sup_loss": 1.4743496241293919 + }, + { + "step": 2913, + "lr": 0.0001, + "sup_loss": 1.5156892412410665 + }, + { + "step": 2914, + "lr": 0.0001, + "sup_loss": 1.5329302618350436 + }, + { + "step": 2915, + "lr": 0.0001, + "sup_loss": 1.5096786930233952 + }, + { + "step": 2916, + "lr": 0.0001, + "sup_loss": 1.5061300623886757 + }, + { + "step": 2917, + "lr": 0.0001, + "sup_loss": 1.4861225653723953 + }, + { + "step": 2918, + "lr": 0.0001, + "sup_loss": 1.4813813358493975 + }, + { + "step": 2919, + "lr": 0.0001, + "sup_loss": 1.498042394317311 + }, + { + "step": 2920, + "lr": 0.0001, + "sup_loss": 1.4998282270935523 + }, + { + "step": 2921, + "lr": 0.0001, + "sup_loss": 1.519771646317869 + }, + { + "step": 2922, + "lr": 0.0001, + "sup_loss": 1.5360457573869457 + }, + { + "step": 2923, + "lr": 0.0001, + "sup_loss": 1.515760876463756 + }, + { + "step": 2924, + "lr": 0.0001, + "sup_loss": 1.4977812834025102 + }, + { + "step": 2925, + "lr": 0.0001, + "sup_loss": 1.5236502353339383 + }, + { + "step": 2926, + "lr": 0.0001, + "sup_loss": 1.525991743661665 + }, + { + "step": 2927, + "lr": 0.0001, + "sup_loss": 1.5368059166231824 + }, + { + "step": 2928, + "lr": 0.0001, + "sup_loss": 1.5083943591674114 + }, + { + "step": 2929, + "lr": 0.0001, + "sup_loss": 1.5063305219116543 + }, + { + "step": 2930, + "lr": 0.0001, + "sup_loss": 1.4945766956807893 + }, + { + "step": 2931, + "lr": 0.0001, + "sup_loss": 1.5028505223603237 + }, + { + "step": 2932, + "lr": 0.0001, + "sup_loss": 1.5046643844422654 + }, + { + "step": 2933, + "lr": 0.0001, + "sup_loss": 1.50017780996385 + }, + { + "step": 2934, + "lr": 0.0001, + "sup_loss": 1.5140106664466795 + }, + { + "step": 2935, + "lr": 0.0001, + "sup_loss": 1.5129459304419053 + }, + { + "step": 2936, + "lr": 0.0001, + "sup_loss": 1.5061596523542125 + }, + { + "step": 2937, + "lr": 0.0001, + "sup_loss": 1.531776055741723 + }, + { + "step": 2938, + "lr": 0.0001, + "sup_loss": 1.5134289360610893 + }, + { + "step": 2939, + "lr": 0.0001, + "sup_loss": 1.4756265559872508 + }, + { + "step": 2940, + "lr": 0.0001, + "sup_loss": 1.5031313727088933 + }, + { + "step": 2941, + "lr": 0.0001, + "sup_loss": 1.5024014792683795 + }, + { + "step": 2942, + "lr": 0.0001, + "sup_loss": 1.5358603412249412 + }, + { + "step": 2943, + "lr": 0.0001, + "sup_loss": 1.5336556706704492 + }, + { + "step": 2944, + "lr": 0.0001, + "sup_loss": 1.4760388451905404 + }, + { + "step": 2945, + "lr": 0.0001, + "sup_loss": 1.5237122140936423 + }, + { + "step": 2946, + "lr": 0.0001, + "sup_loss": 1.5329286652063197 + }, + { + "step": 2947, + "lr": 0.0001, + "sup_loss": 1.5121014163611046 + }, + { + "step": 2948, + "lr": 0.0001, + "sup_loss": 1.5058456580235247 + }, + { + "step": 2949, + "lr": 0.0001, + "sup_loss": 1.5099556605466182 + }, + { + "step": 2950, + "lr": 0.0001, + "sup_loss": 1.4919075945203557, + "lyap1_mean": -8.444442749023438, + "lyap1_max": -8.201986312866211, + "lyap_spec_mean": [ + -8.444441795349121, + -8.854179382324219 + ], + "lyap_bound": -0.10536051565782628 + }, + { + "step": 2951, + "lr": 0.0001, + "sup_loss": 1.503113180250828 + }, + { + "step": 2952, + "lr": 0.0001, + "sup_loss": 1.5098936639690208 + }, + { + "step": 2953, + "lr": 0.0001, + "sup_loss": 1.5092486461367565 + }, + { + "step": 2954, + "lr": 0.0001, + "sup_loss": 1.5367960445610478 + }, + { + "step": 2955, + "lr": 0.0001, + "sup_loss": 1.522864883315146 + }, + { + "step": 2956, + "lr": 0.0001, + "sup_loss": 1.5127335450109312 + }, + { + "step": 2957, + "lr": 0.0001, + "sup_loss": 1.5264390868914406 + }, + { + "step": 2958, + "lr": 0.0001, + "sup_loss": 1.512567130251404 + }, + { + "step": 2959, + "lr": 0.0001, + "sup_loss": 1.5167929114925096 + }, + { + "step": 2960, + "lr": 0.0001, + "sup_loss": 1.5065224056401714 + }, + { + "step": 2961, + "lr": 0.0001, + "sup_loss": 1.5130744500577402 + }, + { + "step": 2962, + "lr": 0.0001, + "sup_loss": 1.513087016566023 + }, + { + "step": 2963, + "lr": 0.0001, + "sup_loss": 1.50230843902988 + }, + { + "step": 2964, + "lr": 0.0001, + "sup_loss": 1.5286429868211855 + }, + { + "step": 2965, + "lr": 0.0001, + "sup_loss": 1.5187251452788435 + }, + { + "step": 2966, + "lr": 0.0001, + "sup_loss": 1.4858335475098872 + }, + { + "step": 2967, + "lr": 0.0001, + "sup_loss": 1.501553510439478 + }, + { + "step": 2968, + "lr": 0.0001, + "sup_loss": 1.5089263566047793 + }, + { + "step": 2969, + "lr": 0.0001, + "sup_loss": 1.5338997360063502 + }, + { + "step": 2970, + "lr": 0.0001, + "sup_loss": 1.4951582449493612 + }, + { + "step": 2971, + "lr": 0.0001, + "sup_loss": 1.512418691412798 + }, + { + "step": 2972, + "lr": 0.0001, + "sup_loss": 1.5262456092497714 + }, + { + "step": 2973, + "lr": 0.0001, + "sup_loss": 1.479397609502761 + }, + { + "step": 2974, + "lr": 0.0001, + "sup_loss": 1.465245434781214 + }, + { + "step": 2975, + "lr": 0.0001, + "sup_loss": 1.5096724850365864 + }, + { + "step": 2976, + "lr": 0.0001, + "sup_loss": 1.5048517241402466 + }, + { + "step": 2977, + "lr": 0.0001, + "sup_loss": 1.502642013000508 + }, + { + "step": 2978, + "lr": 0.0001, + "sup_loss": 1.5482859456096618 + }, + { + "step": 2979, + "lr": 0.0001, + "sup_loss": 1.5421171291496125 + }, + { + "step": 2980, + "lr": 0.0001, + "sup_loss": 1.509523749709621 + }, + { + "step": 2981, + "lr": 0.0001, + "sup_loss": 1.5059555062226182 + }, + { + "step": 2982, + "lr": 0.0001, + "sup_loss": 1.5000585679596967 + }, + { + "step": 2983, + "lr": 0.0001, + "sup_loss": 1.4990640046599086 + }, + { + "step": 2984, + "lr": 0.0001, + "sup_loss": 1.5032385960883194 + }, + { + "step": 2985, + "lr": 0.0001, + "sup_loss": 1.45935519353957 + }, + { + "step": 2986, + "lr": 0.0001, + "sup_loss": 1.5330243328684994 + }, + { + "step": 2987, + "lr": 0.0001, + "sup_loss": 1.5093518019088483 + }, + { + "step": 2988, + "lr": 0.0001, + "sup_loss": 1.5230473923264736 + }, + { + "step": 2989, + "lr": 0.0001, + "sup_loss": 1.505963828685485 + }, + { + "step": 2990, + "lr": 0.0001, + "sup_loss": 1.5267481785276105 + }, + { + "step": 2991, + "lr": 0.0001, + "sup_loss": 1.484002511967848 + }, + { + "step": 2992, + "lr": 0.0001, + "sup_loss": 1.516239336863158 + }, + { + "step": 2993, + "lr": 0.0001, + "sup_loss": 1.5113527859974767 + }, + { + "step": 2994, + "lr": 0.0001, + "sup_loss": 1.5447019155611055 + }, + { + "step": 2995, + "lr": 0.0001, + "sup_loss": 1.5263476241380238 + }, + { + "step": 2996, + "lr": 0.0001, + "sup_loss": 1.5129204967258472 + }, + { + "step": 2997, + "lr": 0.0001, + "sup_loss": 1.443162252776542 + }, + { + "step": 2998, + "lr": 0.0001, + "sup_loss": 1.515408697866678 + }, + { + "step": 2999, + "lr": 0.0001, + "sup_loss": 1.4894827105283397 + } + ], + "evals": [ + { + "step": 0, + "acc": 0.0, + "tok_acc": 0.11072530864197531 + }, + { + "step": 300, + "acc": 0.0, + "tok_acc": 0.38797260802469136 + }, + { + "step": 600, + "acc": 0.0, + "tok_acc": 0.3890335648148148 + }, + { + "step": 900, + "acc": 0.0, + "tok_acc": 0.3890094521604938 + }, + { + "step": 1200, + "acc": 0.0, + "tok_acc": 0.3882619598765432 + }, + { + "step": 1500, + "acc": 0.0, + "tok_acc": 0.38898533950617287 + }, + { + "step": 1800, + "acc": 0.0, + "tok_acc": 0.3879002700617284 + }, + { + "step": 2100, + "acc": 0.0, + "tok_acc": 0.3890576774691358 + }, + { + "step": 2400, + "acc": 0.0, + "tok_acc": 0.39113136574074076 + }, + { + "step": 2700, + "acc": 0.0, + "tok_acc": 0.39134837962962965 + }, + { + "step": 3000, + "acc": 0.0, + "tok_acc": 0.39240933641975306 + } + ], + "final_acc": 0.0, + "final_tok_acc": 0.39240933641975306 +}
\ No newline at end of file diff --git a/srm/scripts/train_hrm_orth.py b/srm/scripts/train_hrm_orth.py new file mode 100644 index 0000000..4d9868b --- /dev/null +++ b/srm/scripts/train_hrm_orth.py @@ -0,0 +1,203 @@ +"""Train HRM-Orth (orthogonal-patched HRM) from scratch on Sudoku. + +Per codex round 2 recommendation (Q6 pivot): patch HRM Block (attn+SwiGLU+rms_norm) +with Lipschitz-bounded versions (cosine attn + OrthLinear+MaxMin + weighted residual). +Keeps HRM's H_level/L_level/ACT framework intact. +""" +from __future__ import annotations +import sys, os, json, math, time, argparse +from pathlib import Path +import numpy as np +import torch + +ROOT = Path("/home/yurenh2/rrm/srm") +sys.path.insert(0, str(ROOT)) + +from models.srm.hrm_orth_v1 import HierarchicalReasoningModel_ACTV1 as HRMOrth +from models.losses import ACTLossHead +from models.sparse_embedding import CastedSparseEmbeddingSignSGD_Distributed +from adam_atan2 import AdamATan2 + + +def build_model(data_path: Path, batch_size: int, device: str, + hidden_size: int = 256, num_heads: int = 4, + H_cycles: int = 2, L_cycles: int = 2, H_layers: int = 4, L_layers: int = 4, + orth_s_min: float = 0.95, cosine_attn_tau: float = 8.0): + train_meta = json.loads((data_path / "train" / "dataset.json").read_text()) + arch_cfg = dict( + H_cycles=H_cycles, H_layers=H_layers, + L_cycles=L_cycles, L_layers=L_layers, + expansion=4, + halt_exploration_prob=0.1, + halt_max_steps=16, + hidden_size=hidden_size, + num_heads=num_heads, + pos_encodings="rope", + puzzle_emb_ndim=hidden_size, + batch_size=batch_size, + vocab_size=train_meta["vocab_size"], + seq_len=train_meta["seq_len"], + num_puzzle_identifiers=train_meta["num_puzzle_identifiers"], + forward_dtype="bfloat16", + orth_s_min=orth_s_min, + cosine_attn_tau=cosine_attn_tau, + ) + with torch.device(device): + base = HRMOrth(arch_cfg) + head = ACTLossHead(base, loss_type="stablemax_cross_entropy") + return head, base, train_meta + + +def load_train_batches(data_path: Path, batch_size: int, n_iters: int, seed: int = 0): + rng = np.random.default_rng(seed) + inputs = np.load(data_path / "train" / "all__inputs.npy") + labels = np.load(data_path / "train" / "all__labels.npy") + pid = np.load(data_path / "train" / "all__puzzle_identifiers.npy") + N = len(inputs) + for _ in range(n_iters): + idx = rng.choice(N, size=batch_size, replace=False) + yield { + "inputs": torch.from_numpy(inputs[idx].astype(np.int32)), + "labels": torch.from_numpy(labels[idx].astype(np.int32)), + "puzzle_identifiers": torch.from_numpy(pid[idx].astype(np.int32)), + } + + +def evaluate(head, base, data_path, n_samples, batch_size, device, seed=42): + rng = np.random.default_rng(seed) + inputs = np.load(data_path / "test" / "all__inputs.npy") + labels = np.load(data_path / "test" / "all__labels.npy") + pid = np.load(data_path / "test" / "all__puzzle_identifiers.npy") + idx_all = rng.choice(len(inputs), size=n_samples, replace=False) + head.eval() + correct = 0; token_correct = 0; token_total = 0 + for s in range(0, n_samples, batch_size): + e = min(s + batch_size, n_samples) + idx = idx_all[s:e] + batch = { + "inputs": torch.from_numpy(inputs[idx].astype(np.int32)).to(device), + "labels": torch.from_numpy(labels[idx].astype(np.int32)).to(device), + "puzzle_identifiers": torch.from_numpy(pid[idx].astype(np.int32)).to(device), + } + with torch.no_grad(): + with torch.device(device): + carry = base.initial_carry(batch) + for _ in range(base.config.halt_max_steps): + carry, outputs = base(carry=carry, batch=batch) + preds = outputs["logits"].argmax(dim=-1) + mask = batch["labels"] > 0 + exact = ((preds == batch["labels"]) | ~mask).all(dim=-1).float() + correct += exact.sum().item() + token_correct += ((preds == batch["labels"]) & mask).sum().item() + token_total += mask.sum().item() + return correct / n_samples, token_correct / max(token_total, 1) + + +def warmup_constant_lr(step, base_lr, warmup): + return base_lr * step / max(1, warmup) if step < warmup else base_lr + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--data-path", default="/home/yurenh2/rrm/data/sudoku-extreme-1k-aug-1000") + ap.add_argument("--n-steps", type=int, default=3000) + ap.add_argument("--batch-size", type=int, default=8) + ap.add_argument("--lr", type=float, default=1e-4) + ap.add_argument("--puzzle-emb-lr", type=float, default=1e-4) + ap.add_argument("--warmup-steps", type=int, default=200) + ap.add_argument("--weight-decay", type=float, default=1.0) + ap.add_argument("--hidden-size", type=int, default=256) + ap.add_argument("--num-heads", type=int, default=4) + ap.add_argument("--H-cycles", type=int, default=2) + ap.add_argument("--L-cycles", type=int, default=2) + ap.add_argument("--H-layers", type=int, default=4) + ap.add_argument("--L-layers", type=int, default=4) + ap.add_argument("--orth-s-min", type=float, default=0.95, help="min diag scale (weak orthogonality)") + ap.add_argument("--cosine-attn-tau", type=float, default=8.0) + ap.add_argument("--seed", type=int, default=42) + ap.add_argument("--eval-every", type=int, default=300) + ap.add_argument("--eval-n", type=int, default=512) + ap.add_argument("--eval-batch-size", type=int, default=32) + ap.add_argument("--out", required=True) + ap.add_argument("--save-ckpt", default="") + args = ap.parse_args() + + device = "cuda" + torch.manual_seed(args.seed); np.random.seed(args.seed) + data_path = Path(args.data_path) + head, base, train_meta = build_model( + data_path, args.batch_size, device, + hidden_size=args.hidden_size, num_heads=args.num_heads, + H_cycles=args.H_cycles, L_cycles=args.L_cycles, + H_layers=args.H_layers, L_layers=args.L_layers, + orth_s_min=args.orth_s_min, cosine_attn_tau=args.cosine_attn_tau, + ) + n_params = sum(p.numel() for p in head.parameters()) + print(f"Built HRM-Orth | params={n_params:,} | hidden={args.hidden_size} " + f"H_layers={args.H_layers} L_layers={args.L_layers} " + f"s_min={args.orth_s_min} τ={args.cosine_attn_tau}") + + puzzle_emb_opt = CastedSparseEmbeddingSignSGD_Distributed( + base.inner.puzzle_emb.buffers(), lr=0, weight_decay=args.weight_decay, world_size=1) + main_opt = AdamATan2(head.parameters(), lr=0, betas=(0.9, 0.95), weight_decay=args.weight_decay) + + acc0, tacc0 = evaluate(head, base, data_path, args.eval_n, args.eval_batch_size, device) + print(f"=== step 0 (random init): exact_acc = {acc0:.4f} token_acc = {tacc0:.4f} ===") + + log = {"args": vars(args), "n_params": n_params, "initial_acc": acc0, "initial_tok_acc": tacc0, "steps": [], "evals": []} + log["evals"].append({"step": 0, "acc": acc0, "tok_acc": tacc0}) + t0 = time.time() + train_iter = load_train_batches(data_path, args.batch_size, args.n_steps, seed=args.seed) + + for step, batch in enumerate(train_iter): + batch = {k: v.to(device) for k, v in batch.items()} + cur_lr = warmup_constant_lr(step, args.lr, args.warmup_steps) + cur_pe_lr = warmup_constant_lr(step, args.puzzle_emb_lr, args.warmup_steps) + for pg in main_opt.param_groups: pg["lr"] = cur_lr + for pg in puzzle_emb_opt.param_groups: pg["lr"] = cur_pe_lr + + head.train() + with torch.device(device): + carry = base.initial_carry(batch) + sup_loss_sum = 0.0; n_loss = 0 + for _ in range(base.config.halt_max_steps): + carry, l, metrics, _, all_finish = head(return_keys=[], carry=carry, batch=batch) + sup_loss_sum = sup_loss_sum + l + n_loss += 1 + if all_finish: break + sup_loss = sup_loss_sum / max(n_loss, 1) / args.batch_size + + puzzle_emb_opt.zero_grad(set_to_none=True) + main_opt.zero_grad(set_to_none=True) + sup_loss.backward() + torch.nn.utils.clip_grad_norm_([p for p in head.parameters() if p.requires_grad], 1.0) + main_opt.step() + puzzle_emb_opt.step() + + rec = {"step": step, "lr": cur_lr, "sup_loss": float(sup_loss.item())} + log["steps"].append(rec) + if step % 25 == 0 or step == args.n_steps - 1: + print(f" [{step:>4}/{args.n_steps}] dt={time.time()-t0:.0f}s lr={cur_lr:.1e} " + f"sup={rec['sup_loss']:.4f}", flush=True) + + if (step + 1) % args.eval_every == 0 or step == args.n_steps - 1: + acc, tacc = evaluate(head, base, data_path, args.eval_n, args.eval_batch_size, device) + print(f" >> EVAL @ {step+1}: exact_acc={acc:.4f} tok_acc={tacc:.4f} (Δ init: {acc-acc0:+.4f})", flush=True) + log["evals"].append({"step": step + 1, "acc": acc, "tok_acc": tacc}) + + log["final_acc"] = log["evals"][-1]["acc"] + log["final_tok_acc"] = log["evals"][-1]["tok_acc"] + Path(args.out).parent.mkdir(parents=True, exist_ok=True) + Path(args.out).write_text(json.dumps(log, indent=2)) + print(f"\n=== DONE === init {acc0:.4f} → final {log['final_acc']:.4f} log → {args.out}") + + if args.save_ckpt: + Path(args.save_ckpt).parent.mkdir(parents=True, exist_ok=True) + torch.save({"state_dict": head.state_dict(), "args": vars(args), + "n_steps_trained": args.n_steps, "final_acc": log["final_acc"], "n_params": n_params}, + args.save_ckpt) + print(f"checkpoint → {args.save_ckpt}") + + +if __name__ == "__main__": + main() diff --git a/srm/scripts/train_srm.py b/srm/scripts/train_srm.py new file mode 100644 index 0000000..036ab82 --- /dev/null +++ b/srm/scripts/train_srm.py @@ -0,0 +1,300 @@ +"""Train SRM-Joint-AOL from scratch on Sudoku 1k (or any HRM-format dataset). + +By construction the SRM joint step is ≤ κ-Lipschitz in P-norm, so this trainer +uses ONLY supervised ACT loss — no CF regularizer needed. λ_1 is logged as +a diagnostic; it should stay ≤ log((1-α)+α·κ) per micro-step (e.g. -0.105 for κ=0.9, α=1). + +Usage (run from /home/yurenh2/rrm/srm/): + python scripts/train_srm.py --n-steps 3000 --batch-size 8 \ + --out runs/srm_v1_sudoku_3k.json \ + --save-ckpt ckpts/srm_v1_3k.pt +""" +from __future__ import annotations +import sys, os, json, math, time, argparse +from pathlib import Path +import numpy as np +import torch + +ROOT = Path("/home/yurenh2/rrm/srm") +sys.path.insert(0, str(ROOT)) + +from models.srm.srm_aol_v1 import ( + StableRecursionModel_ACTV1, + StableRecursionModel_ACTV1_Inner, + measure_lipschitz_constant, +) +from models.losses import ACTLossHead +from models.sparse_embedding import CastedSparseEmbeddingSignSGD_Distributed +from adam_atan2 import AdamATan2 + + +def build_srm_from_scratch(data_path: Path, batch_size: int, device: str, + hidden_size: int = 512, + n_iters: int = 12, + n_aol_layers: int = 2, + kappa: float = 0.9, + eta: float = 1.0, + alpha: float = 1.0): + train_meta = json.loads((data_path / "train" / "dataset.json").read_text()) + arch_cfg = dict( + hidden_size=hidden_size, + n_iters=n_iters, + n_aol_layers=n_aol_layers, + kappa=kappa, eta=eta, alpha=alpha, + halt_max_steps=16, halt_exploration_prob=0.1, + puzzle_emb_ndim=hidden_size, + batch_size=batch_size, + vocab_size=train_meta["vocab_size"], + seq_len=train_meta["seq_len"], + num_puzzle_identifiers=train_meta["num_puzzle_identifiers"], + forward_dtype="bfloat16", + ) + with torch.device(device): + base = StableRecursionModel_ACTV1(arch_cfg) + head = ACTLossHead(base, loss_type="stablemax_cross_entropy") + return head, base, train_meta + + +@torch.no_grad() +def compute_joint_lyap_spec_srm(inner: StableRecursionModel_ACTV1_Inner, batch, k_lyap, n_iters_for_lyap, + device, seed): + """Top-k joint Lyapunov spectrum for SRM dynamics. + + Tangent: at each step the Jacobian J = ∂T/∂(h,l) is applied to all k orthonormal + columns via JVP. Then QR re-orthogonalize. + """ + cfg = inner.config + B = batch["inputs"].shape[0] + seq_full = cfg.seq_len + inner.puzzle_emb_len + hidden = cfg.hidden_size + D = seq_full * hidden + + z_H = inner.H_init.unsqueeze(0).expand(B, seq_full, hidden).clone().to(inner.forward_dtype) + z_L = inner.L_init.unsqueeze(0).expand(B, seq_full, hidden).clone().to(inner.forward_dtype) + input_emb = inner._input_embeddings(batch["inputs"], batch["puzzle_identifiers"]) + + g = torch.Generator(device=device).manual_seed(seed) + Q0 = torch.randn(B, 2 * D, k_lyap, device=device, dtype=torch.float32, generator=g) + Q, _ = torch.linalg.qr(Q0) + log_R_sum = torch.zeros(B, k_lyap, device=device, dtype=torch.float32) + n_steps_lyap = 0 + + for _ in range(n_iters_for_lyap): + # JVP through srm_block w.r.t. (z_H, z_L) — one tangent column at a time + new_cols = [] + for i in range(k_lyap): + v_H = Q[:, :D, i].reshape(B, seq_full, hidden).to(inner.forward_dtype) + v_L = Q[:, D:, i].reshape(B, seq_full, hidden).to(inner.forward_dtype) + + def f(zH_zL): + zH, zL = zH_zL[:, :hidden, :].permute(0, 2, 1).contiguous(), zH_zL[:, hidden:, :].permute(0, 2, 1).contiguous() + hN, lN = inner.srm_block(zH, zL, input_emb) + return torch.stack([hN, lN], dim=1).reshape(B, 2 * hidden, seq_full) + + # Easier: use 2 JVPs separately if function takes (h, l) + def f_joint(zH, zL): + return inner.srm_block(zH, zL, input_emb) + (hN, lN), (dh_out, dl_out) = torch.autograd.functional.jvp( + f_joint, (z_H, z_L), v=(v_H, v_L), create_graph=False, strict=False) + dh_col = dh_out.reshape(B, D).to(torch.float32) + dl_col = dl_out.reshape(B, D).to(torch.float32) + new_cols.append(torch.cat([dh_col, dl_col], dim=-1)) + Q = torch.stack(new_cols, dim=-1) # (B, 2D, k) + # Advance state + z_H, z_L = hN, lN + # Orthonormalize + Q, R = torch.linalg.qr(Q) + log_R_sum = log_R_sum + R.diagonal(dim1=-2, dim2=-1).abs().clamp_min(1e-30).log() + n_steps_lyap += 1 + + return log_R_sum / max(n_steps_lyap, 1) # (B, k) + + +def load_train_batches(data_path: Path, batch_size: int, n_iters: int, seed: int = 0): + rng = np.random.default_rng(seed) + inputs = np.load(data_path / "train" / "all__inputs.npy") + labels = np.load(data_path / "train" / "all__labels.npy") + pid = np.load(data_path / "train" / "all__puzzle_identifiers.npy") + N = len(inputs) + for _ in range(n_iters): + idx = rng.choice(N, size=batch_size, replace=False) + yield { + "inputs": torch.from_numpy(inputs[idx].astype(np.int32)), + "labels": torch.from_numpy(labels[idx].astype(np.int32)), + "puzzle_identifiers": torch.from_numpy(pid[idx].astype(np.int32)), + } + + +def evaluate(head, base, data_path, n_samples, batch_size, device, seed=42): + rng = np.random.default_rng(seed) + inputs = np.load(data_path / "test" / "all__inputs.npy") + labels = np.load(data_path / "test" / "all__labels.npy") + pid = np.load(data_path / "test" / "all__puzzle_identifiers.npy") + idx_all = rng.choice(len(inputs), size=n_samples, replace=False) + head.eval() + correct = 0; token_correct = 0; token_total = 0 + for s in range(0, n_samples, batch_size): + e = min(s + batch_size, n_samples) + idx = idx_all[s:e] + batch = { + "inputs": torch.from_numpy(inputs[idx].astype(np.int32)).to(device), + "labels": torch.from_numpy(labels[idx].astype(np.int32)).to(device), + "puzzle_identifiers": torch.from_numpy(pid[idx].astype(np.int32)).to(device), + } + with torch.no_grad(): + with torch.device(device): + carry = base.initial_carry(batch) + for _ in range(base.config.halt_max_steps): + carry, outputs = base(carry=carry, batch=batch) + preds = outputs["logits"].argmax(dim=-1) + mask = batch["labels"] > 0 + exact = ((preds == batch["labels"]) | ~mask).all(dim=-1).float() + correct += exact.sum().item() + token_correct += ((preds == batch["labels"]) & mask).sum().item() + token_total += mask.sum().item() + return correct / n_samples, token_correct / max(token_total, 1) + + +def warmup_constant_lr(step, base_lr, warmup): + return base_lr * step / max(1, warmup) if step < warmup else base_lr + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--data-path", default="/home/yurenh2/rrm/data/sudoku-extreme-1k-aug-1000") + ap.add_argument("--n-steps", type=int, default=3000) + ap.add_argument("--batch-size", type=int, default=8) + ap.add_argument("--lr", type=float, default=1e-4) + ap.add_argument("--puzzle-emb-lr", type=float, default=1e-4) + ap.add_argument("--warmup-steps", type=int, default=200) + ap.add_argument("--weight-decay", type=float, default=1.0) + # SRM specific + ap.add_argument("--hidden-size", type=int, default=512) + ap.add_argument("--n-iters", type=int, default=12) + ap.add_argument("--n-aol-layers", type=int, default=2) + ap.add_argument("--kappa", type=float, default=0.9) + ap.add_argument("--eta", type=float, default=1.0) + ap.add_argument("--alpha", type=float, default=1.0) + # Diagnostic + ap.add_argument("--k-lyap", type=int, default=2) + ap.add_argument("--lyap-iters", type=int, default=8, help="number of SRM steps for Lyapunov measurement") + ap.add_argument("--lyap-every", type=int, default=50, help="measure Lyapunov every N steps (expensive)") + # Eval / logging + ap.add_argument("--seed", type=int, default=42) + ap.add_argument("--eval-every", type=int, default=250) + ap.add_argument("--eval-n", type=int, default=512) + ap.add_argument("--eval-batch-size", type=int, default=32) + ap.add_argument("--out", required=True) + ap.add_argument("--save-ckpt", default="") + args = ap.parse_args() + + device = "cuda" + torch.manual_seed(args.seed); np.random.seed(args.seed) + data_path = Path(args.data_path) + head, base, train_meta = build_srm_from_scratch( + data_path, args.batch_size, device, + hidden_size=args.hidden_size, n_iters=args.n_iters, + n_aol_layers=args.n_aol_layers, + kappa=args.kappa, eta=args.eta, alpha=args.alpha, + ) + n_params = sum(p.numel() for p in head.parameters()) + print(f"Built SRM-AOL from scratch | params={n_params:,} | " + f"hidden={args.hidden_size} n_iters={args.n_iters} n_aol={args.n_aol_layers} " + f"κ={args.kappa} η={args.eta} α={args.alpha}") + + puzzle_emb_opt = CastedSparseEmbeddingSignSGD_Distributed( + base.inner.puzzle_emb.buffers(), lr=0, + weight_decay=args.weight_decay, world_size=1, + ) + main_opt = AdamATan2(head.parameters(), lr=0, betas=(0.9, 0.95), weight_decay=args.weight_decay) + + # Initial eval (random init baseline) + Lipschitz check + acc0, tacc0 = evaluate(head, base, data_path, args.eval_n, args.eval_batch_size, device) + print(f"=== step 0 (random init): exact_acc = {acc0:.4f} token_acc = {tacc0:.4f} ===") + # Sample one batch for the initial Lipschitz check + probe_batch = next(load_train_batches(data_path, args.batch_size, 1, seed=999)) + probe_batch = {k: v.to(device) for k, v in probe_batch.items()} + lip0 = measure_lipschitz_constant(base.inner, probe_batch, n_probes=32) + print(f" Lip init: emp_max={lip0['lip_emp_max']:.4f} bound={lip0['lip_theoretical_bound']:.4f}") + + log = { + "args": vars(args), "n_params": n_params, + "initial_acc": acc0, "initial_tok_acc": tacc0, + "initial_lip": lip0, + "steps": [], "evals": [], + } + log["evals"].append({"step": 0, "acc": acc0, "tok_acc": tacc0}) + t0 = time.time() + train_iter = load_train_batches(data_path, args.batch_size, args.n_steps, seed=args.seed) + + for step, batch in enumerate(train_iter): + batch = {k: v.to(device) for k, v in batch.items()} + cur_lr = warmup_constant_lr(step, args.lr, args.warmup_steps) + cur_pe_lr = warmup_constant_lr(step, args.puzzle_emb_lr, args.warmup_steps) + for pg in main_opt.param_groups: pg["lr"] = cur_lr + for pg in puzzle_emb_opt.param_groups: pg["lr"] = cur_pe_lr + + head.train() + with torch.device(device): + carry = base.initial_carry(batch) + sup_loss_sum = 0.0; n_loss = 0 + for _ in range(base.config.halt_max_steps): + carry, l, metrics, _, all_finish = head(return_keys=[], carry=carry, batch=batch) + sup_loss_sum = sup_loss_sum + l + n_loss += 1 + if all_finish: break + sup_loss = sup_loss_sum / max(n_loss, 1) / args.batch_size + + puzzle_emb_opt.zero_grad(set_to_none=True) + main_opt.zero_grad(set_to_none=True) + sup_loss.backward() + torch.nn.utils.clip_grad_norm_([p for p in head.parameters() if p.requires_grad], 1.0) + main_opt.step() + puzzle_emb_opt.step() + + rec = {"step": step, "lr": cur_lr, "sup_loss": float(sup_loss.item())} + + # Lyapunov diagnostic (every lyap_every steps) + if step % args.lyap_every == 0: + lyap_spec = compute_joint_lyap_spec_srm( + base.inner, batch, k_lyap=args.k_lyap, + n_iters_for_lyap=args.lyap_iters, + device=device, seed=args.seed + step, + ) # (B, k) + rec["lyap1_mean"] = float(lyap_spec[:, 0].mean().item()) + rec["lyap1_max"] = float(lyap_spec[:, 0].max().item()) + rec["lyap_spec_mean"] = lyap_spec.mean(dim=0).cpu().tolist() + log_kappa_bound = math.log((1 - args.alpha) + args.alpha * args.kappa) + rec["lyap_bound"] = log_kappa_bound + log["steps"].append(rec) + if step % 25 == 0 or step == args.n_steps - 1: + extra = f" λ={rec.get('lyap1_mean', float('nan')):+.4f} max={rec.get('lyap1_max', float('nan')):+.4f}" if "lyap1_mean" in rec else "" + print(f" [{step:>4}/{args.n_steps}] dt={time.time()-t0:.0f}s lr={cur_lr:.1e} " + f"sup={rec['sup_loss']:.4f}{extra}", flush=True) + + if (step + 1) % args.eval_every == 0 or step == args.n_steps - 1: + acc, tacc = evaluate(head, base, data_path, args.eval_n, args.eval_batch_size, device) + print(f" >> EVAL @ {step+1}: exact_acc={acc:.4f} tok_acc={tacc:.4f} " + f"(Δ init: {acc-acc0:+.4f})", flush=True) + log["evals"].append({"step": step + 1, "acc": acc, "tok_acc": tacc}) + + log["final_acc"] = log["evals"][-1]["acc"] + log["final_tok_acc"] = log["evals"][-1]["tok_acc"] + Path(args.out).parent.mkdir(parents=True, exist_ok=True) + Path(args.out).write_text(json.dumps(log, indent=2)) + print(f"\n=== DONE === init {acc0:.4f} → final {log['final_acc']:.4f} log → {args.out}") + + if args.save_ckpt: + Path(args.save_ckpt).parent.mkdir(parents=True, exist_ok=True) + torch.save({ + "state_dict": head.state_dict(), + "args": vars(args), + "n_steps_trained": args.n_steps, + "final_acc": log["final_acc"], + "n_params": n_params, + }, args.save_ckpt) + print(f"checkpoint → {args.save_ckpt}") + + +if __name__ == "__main__": + main() diff --git a/srm/utils/functions.py b/srm/utils/functions.py new file mode 100644 index 0000000..b123636 --- /dev/null +++ b/srm/utils/functions.py @@ -0,0 +1,19 @@ +import importlib +import inspect + + +def load_model_class(identifier: str, prefix: str = "models."): + module_path, class_name = identifier.split('@') + + # Import the module + module = importlib.import_module(prefix + module_path) + cls = getattr(module, class_name) + + return cls + + +def get_model_source_path(identifier: str, prefix: str = "models."): + module_path, class_name = identifier.split('@') + + module = importlib.import_module(prefix + module_path) + return inspect.getsourcefile(module) |