From 10db7b5e7ce5152202627e89f1f2479cf973e51d Mon Sep 17 00:00:00 2001 From: kavlahkaff Date: Wed, 26 Aug 2026 12:52:29 +0200 Subject: [PATCH 1/2] add initial config proposer --- .../ProposeInitialConfigTutorial.ipynb | 450 + benchmarking/tuning/README.md | 42 + .../tuning/generate_initial_configs.py | 375 + mkdocs.yml | 1 + pyproject.toml | 10 + src/autoencodix/__init__.py | 2 + src/autoencodix/tuning/__init__.py | 3 + src/autoencodix/tuning/_propose.py | 196 + src/autoencodix/tuning/data/__init__.py | 0 .../tuning/data/initial_configs.json | 13690 ++++++++++++++++ .../test_propose_initial_config.py | 202 + 11 files changed, 14971 insertions(+) create mode 100644 Tutorials/DeepDives/ProposeInitialConfigTutorial.ipynb create mode 100644 benchmarking/tuning/README.md create mode 100644 benchmarking/tuning/generate_initial_configs.py create mode 100644 src/autoencodix/tuning/__init__.py create mode 100644 src/autoencodix/tuning/_propose.py create mode 100644 src/autoencodix/tuning/data/__init__.py create mode 100644 src/autoencodix/tuning/data/initial_configs.json create mode 100644 tests/test_tuning/test_propose_initial_config.py diff --git a/Tutorials/DeepDives/ProposeInitialConfigTutorial.ipynb b/Tutorials/DeepDives/ProposeInitialConfigTutorial.ipynb new file mode 100644 index 00000000..4903026f --- /dev/null +++ b/Tutorials/DeepDives/ProposeInitialConfigTutorial.ipynb @@ -0,0 +1,450 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "819d24be", + "metadata": {}, + "source": [ + "# Propose an Initial Config\n", + "\n", + "`autoencodix.propose_initial_config()` gives you a strong starting hyperparameter config for\n", + "`Vanillix`, `Varix`, `Ontix`, and `Disentanglix` instead of hand-picking one or accepting the\n", + "generic schema defaults.\n", + "\n", + "Under the hood, it's a lookup into a small ranked portfolio computed **offline** via Syne Tune's\n", + "zero-shot transfer-learning tooling against the BBOmix benchmark (105,000 autoencodix training\n", + "runs across 5 architectures, 2 datasets, and many downstream tasks). No optimizer runs at call\n", + "time, and `syne-tune` is **not** a runtime dependency of this package. This function is a plain\n", + "JSON lookup + Pydantic validation.\n", + "\n", + "See `benchmarking/tuning/generate_initial_configs.py` for how the shipped portfolio was generated." + ] + }, + { + "cell_type": "markdown", + "id": "e374d1a5", + "metadata": {}, + "source": [ + "## 1) Quick start" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ffbf8a21", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T10:37:28.614085Z", + "iopub.status.busy": "2026-08-26T10:37:28.613869Z", + "iopub.status.idle": "2026-08-26T10:37:35.046675Z", + "shell.execute_reply": "2026-08-26T10:37:35.046253Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "VarixConfig\n", + "epochs: 300 | checkpoint_interval: 300\n", + "latent_dim: 58 | beta: 0.1497123009757529\n" + ] + } + ], + "source": [ + "import autoencodix as acx\n", + "\n", + "config = acx.propose_initial_config(\"varix\")\n", + "print(type(config).__name__)\n", + "print(\"epochs:\", config.epochs, \"| checkpoint_interval:\", config.checkpoint_interval)\n", + "print(\"latent_dim:\", config.latent_dim, \"| beta:\", config.beta)" + ] + }, + { + "cell_type": "markdown", + "id": "726412df", + "metadata": {}, + "source": [ + "With no other arguments, this returns the top-ranked config from the **combined** portfolio\n", + "(pooling all BBOmix source tasks across datasets) for the `\"downstream\"` objective (maximizing\n", + "aggregate downstream classification performance, at the full training budget). That combination\n", + "is the recommended default: it's the portfolio expected to generalize best to a dataset that\n", + "wasn't part of the original benchmark, which is the situation most callers of this function will\n", + "actually be in." + ] + }, + { + "cell_type": "markdown", + "id": "9ba57844", + "metadata": {}, + "source": [ + "## 2) Objectives: `\"downstream\"` vs. `\"reconstruction\"`" + ] + }, + { + "cell_type": "markdown", + "id": "c05e8af0", + "metadata": {}, + "source": [ + "There are exactly two objective *kinds*:\n", + "\n", + "- `\"downstream\"` (the default) — maximizes an aggregate downstream classification score. This is\n", + " only ever evaluated at the final epoch (there's no per-epoch downstream signal in the benchmark\n", + " data), so it always recommends the full training budget.\n", + "- `\"reconstruction\"` — minimizes reconstruction loss, which *was* recorded every epoch during the\n", + " sweep. This objective has a genuine fidelity axis: pass `budget_epochs` to get a config tuned\n", + " for training that long, not for 300 epochs." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a7a39881", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T10:37:35.048162Z", + "iopub.status.busy": "2026-08-26T10:37:35.047991Z", + "iopub.status.idle": "2026-08-26T10:37:35.050209Z", + "shell.execute_reply": "2026-08-26T10:37:35.049900Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "downstream epochs: 300\n", + "reconstruction (full) epochs: 300\n", + "reconstruction (budget=25) epochs: 25 | checkpoint_interval: 25\n" + ] + } + ], + "source": [ + "config_downstream = acx.propose_initial_config(\"varix\", objective=\"downstream\")\n", + "config_recon_full = acx.propose_initial_config(\"varix\", objective=\"reconstruction\")\n", + "config_recon_short = acx.propose_initial_config(\n", + " \"varix\", objective=\"reconstruction\", budget_epochs=25\n", + ")\n", + "\n", + "print(\"downstream epochs: \", config_downstream.epochs)\n", + "print(\"reconstruction (full) epochs: \", config_recon_full.epochs)\n", + "print(\"reconstruction (budget=25) epochs: \", config_recon_short.epochs,\n", + " \"| checkpoint_interval:\", config_recon_short.checkpoint_interval)" + ] + }, + { + "cell_type": "markdown", + "id": "536f16de", + "metadata": {}, + "source": [ + "`budget_epochs` snaps to the nearest of a fixed grid (`10, 25, 50, 100, 150, 200, 300`) and warns\n", + "when it does:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e40cf20c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T10:37:35.051386Z", + "iopub.status.busy": "2026-08-26T10:37:35.051304Z", + "iopub.status.idle": "2026-08-26T10:37:35.052963Z", + "shell.execute_reply": "2026-08-26T10:37:35.052651Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "snapped epochs: 50\n", + "warning: budget_epochs=40 is not one of the available budgets [10, 25, 50, 100, 150, 200, 300]; snapped to 50.\n" + ] + } + ], + "source": [ + "import warnings\n", + "\n", + "with warnings.catch_warnings(record=True) as caught:\n", + " warnings.simplefilter(\"always\")\n", + " config = acx.propose_initial_config(\"varix\", objective=\"reconstruction\", budget_epochs=40)\n", + " print(\"snapped epochs:\", config.epochs)\n", + " print(\"warning:\", caught[0].message)" + ] + }, + { + "cell_type": "markdown", + "id": "f06092c5", + "metadata": {}, + "source": [ + "Combining `objective=\"downstream\"` with `budget_epochs` raises a `ValueError` — there's nothing\n", + "for it to act on." + ] + }, + { + "cell_type": "markdown", + "id": "003773c8", + "metadata": {}, + "source": [ + "## 3) Scoping to a benchmark dataset (secondary, optional)" + ] + }, + { + "cell_type": "markdown", + "id": "ce7f7ae3", + "metadata": {}, + "source": [ + "`dataset=None` (the default, used above) is the recommended path for a new dataset. If you\n", + "specifically want the portfolio derived from just one of the BBOmix benchmark's own datasets, pass\n", + "its name:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "309c6871", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T10:37:35.054168Z", + "iopub.status.busy": "2026-08-26T10:37:35.054108Z", + "iopub.status.idle": "2026-08-26T10:37:35.055886Z", + "shell.execute_reply": "2026-08-26T10:37:35.055601Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "300 300\n" + ] + } + ], + "source": [ + "config_tcga = acx.propose_initial_config(\"varix\", dataset=\"tcga\")\n", + "config_schc = acx.propose_initial_config(\"varix\", dataset=\"schc\")\n", + "print(config_tcga.epochs, config_schc.epochs)" + ] + }, + { + "cell_type": "markdown", + "id": "4923f87e", + "metadata": {}, + "source": [ + "`dataset` is validated dynamically against whatever's actually in the shipped portfolio — not a\n", + "fixed set baked into the function signature. An unknown name raises a `ValueError` that tells you\n", + "what is available:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "24962f26", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T10:37:35.057258Z", + "iopub.status.busy": "2026-08-26T10:37:35.057189Z", + "iopub.status.idle": "2026-08-26T10:37:35.058931Z", + "shell.execute_reply": "2026-08-26T10:37:35.058605Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unknown dataset 'my_new_cohort' for architecture 'varix'. Available datasets: ['schc', 'tcga']. Omit `dataset` (or pass None) to use the combined, cross-dataset portfolio -- the recommended default for a new dataset that wasn't part of the BBOmix benchmark.\n" + ] + } + ], + "source": [ + "try:\n", + " acx.propose_initial_config(\"varix\", dataset=\"my_new_cohort\")\n", + "except ValueError as e:\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "id": "a3cdb44b", + "metadata": {}, + "source": [ + "## 4) Getting several ranked candidates" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "79d26a0f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T10:37:35.060062Z", + "iopub.status.busy": "2026-08-26T10:37:35.059990Z", + "iopub.status.idle": "2026-08-26T10:37:35.061984Z", + "shell.execute_reply": "2026-08-26T10:37:35.061585Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 latent_dim: 58 | n_layers: 3 | lr: 0.0033023196273975707\n", + "2 latent_dim: 15 | n_layers: 4 | lr: 8.629522298260548e-05\n", + "3 latent_dim: 57 | n_layers: 3 | lr: 0.0003654758769476195\n" + ] + } + ], + "source": [ + "candidates = acx.propose_initial_config(\"varix\", top_k=3)\n", + "for i, c in enumerate(candidates, 1):\n", + " print(i, \"latent_dim:\", c.latent_dim, \"| n_layers:\", c.n_layers, \"| lr:\", c.learning_rate)" + ] + }, + { + "cell_type": "markdown", + "id": "e85f4248", + "metadata": {}, + "source": [ + "## 5) Overriding fields" + ] + }, + { + "cell_type": "markdown", + "id": "6a2b6c4e", + "metadata": {}, + "source": [ + "Any keyword you pass through `**overrides` is applied on top of the proposed hyperparameters\n", + "before the Config object is constructed — so you can take the proposal as a base and tweak just\n", + "what you care about. Pydantic still validates the result, so an out-of-range override raises the\n", + "normal `ValidationError`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "68380527", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T10:37:35.063183Z", + "iopub.status.busy": "2026-08-26T10:37:35.063114Z", + "iopub.status.idle": "2026-08-26T10:37:35.064988Z", + "shell.execute_reply": "2026-08-26T10:37:35.064698Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8 0.001\n", + "rejected: Input should be greater than or equal to 1\n" + ] + } + ], + "source": [ + "from pydantic import ValidationError\n", + "\n", + "config = acx.propose_initial_config(\"varix\", latent_dim=8, learning_rate=1e-3)\n", + "print(config.latent_dim, config.learning_rate)\n", + "\n", + "try:\n", + " acx.propose_initial_config(\"varix\", latent_dim=-1)\n", + "except ValidationError as e:\n", + " print(\"rejected:\", e.errors()[0][\"msg\"])" + ] + }, + { + "cell_type": "markdown", + "id": "e68525f3", + "metadata": {}, + "source": [ + "## 6) Architectures without a BBOmix portfolio" + ] + }, + { + "cell_type": "markdown", + "id": "e1f17fef", + "metadata": {}, + "source": [ + "Only `vanillix`, `varix`, `ontix`, and `disentanglix` have a BBOmix-derived portfolio. Other\n", + "architectures with a Config class (e.g. `stackix`, `xmodalix`, `maskix`) raise a `ValueError` by\n", + "default; pass `allow_fallback_to_defaults=True` to instead get that class's plain schema defaults\n", + "with a warning." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "11b3d074", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-26T10:37:35.066274Z", + "iopub.status.busy": "2026-08-26T10:37:35.066204Z", + "iopub.status.idle": "2026-08-26T10:37:35.068145Z", + "shell.execute_reply": "2026-08-26T10:37:35.067842Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unsupported architecture 'stackix'. propose_initial_config has a BBOmix-derived portfolio for: ['disentanglix', 'ontix', 'vanillix', 'varix']. Pass allow_fallback_to_defaults=True to fall back to plain schema defaults for any other architecture with a Config class.\n", + "StackixConfig epochs: 3\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/fz/3nckfp3n60s2f4p0_rb0vbph0000gn/T/ipykernel_4334/2371638015.py:6: UserWarning: No BBOmix-derived portfolio for architecture 'stackix'; falling back to StackixConfig schema defaults. Supported architectures with a portfolio: ['disentanglix', 'ontix', 'vanillix', 'varix'].\n", + " config = acx.propose_initial_config(\"stackix\", allow_fallback_to_defaults=True)\n" + ] + } + ], + "source": [ + "try:\n", + " acx.propose_initial_config(\"stackix\")\n", + "except ValueError as e:\n", + " print(e)\n", + "\n", + "config = acx.propose_initial_config(\"stackix\", allow_fallback_to_defaults=True)\n", + "print(type(config).__name__, \"epochs:\", config.epochs)" + ] + }, + { + "cell_type": "markdown", + "id": "3ca01cd8", + "metadata": {}, + "source": [ + "## What's next\n", + "\n", + "This function only ever proposes an *initial* config, so it has no way to learn from your own\n", + "training runs. To optimize your model further you can use actual HPO methods. These steps are explained for Syne Tune in `HyperparameterOptimizationTutorial.ipynb` and Optuna in `HyperparameterOptimizationOptunaTutorial.ipynb`." + ] + } + ], + "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": 5 +} diff --git a/benchmarking/tuning/README.md b/benchmarking/tuning/README.md new file mode 100644 index 00000000..cdce3b0e --- /dev/null +++ b/benchmarking/tuning/README.md @@ -0,0 +1,42 @@ +# Initial-config generation report + +## vanillix + downstream: mean percentile 96.5 (n=7 held-out tasks) + reconstruction@10: mean percentile 68.0 (n=7 held-out tasks) + reconstruction@25: mean percentile 76.4 (n=7 held-out tasks) + reconstruction@50: mean percentile 63.8 (n=7 held-out tasks) + reconstruction@100: mean percentile 71.6 (n=7 held-out tasks) + reconstruction@150: mean percentile 61.5 (n=7 held-out tasks) + reconstruction@200: mean percentile 70.5 (n=7 held-out tasks) + reconstruction@300: mean percentile 76.5 (n=7 held-out tasks) + +## varix + downstream: mean percentile 72.8 (n=7 held-out tasks) + reconstruction@10: mean percentile 52.7 (n=7 held-out tasks) + reconstruction@25: mean percentile 71.2 (n=7 held-out tasks) + reconstruction@50: mean percentile 54.6 (n=7 held-out tasks) + reconstruction@100: mean percentile 55.4 (n=7 held-out tasks) + reconstruction@150: mean percentile 60.2 (n=7 held-out tasks) + reconstruction@200: mean percentile 57.5 (n=7 held-out tasks) + reconstruction@300: mean percentile 67.2 (n=7 held-out tasks) + +## ontix + downstream: mean percentile 62.8 (n=14 held-out tasks) + reconstruction@10: mean percentile 64.6 (n=14 held-out tasks) + reconstruction@25: mean percentile 55.4 (n=14 held-out tasks) + reconstruction@50: mean percentile 48.9 (n=14 held-out tasks) + reconstruction@100: mean percentile 50.6 (n=14 held-out tasks) + reconstruction@150: mean percentile 57.0 (n=14 held-out tasks) + reconstruction@200: mean percentile 50.2 (n=14 held-out tasks) + reconstruction@300: mean percentile 53.2 (n=14 held-out tasks) + +## disentanglix + downstream: mean percentile 62.0 (n=7 held-out tasks) + reconstruction@10: mean percentile 52.2 (n=7 held-out tasks) + reconstruction@25: mean percentile 71.5 (n=7 held-out tasks) + reconstruction@50: mean percentile 59.3 (n=7 held-out tasks) + reconstruction@100: mean percentile 68.0 (n=7 held-out tasks) + reconstruction@150: mean percentile 58.0 (n=7 held-out tasks) + reconstruction@200: mean percentile 47.6 (n=7 held-out tasks) + reconstruction@300: mean percentile 54.5 (n=7 held-out tasks) + diff --git a/benchmarking/tuning/generate_initial_configs.py b/benchmarking/tuning/generate_initial_configs.py new file mode 100644 index 00000000..cdbfdfb6 --- /dev/null +++ b/benchmarking/tuning/generate_initial_configs.py @@ -0,0 +1,375 @@ +"""Offline generator for `src/autoencodix/tuning/data/initial_configs.json`. + +Dev-only script -- requires `syne-tune` (see the `dev` dependency group in +`pyproject.toml`). It is never imported by the shipped `autoencodix` package. + +It fits Syne Tune's `ZeroShotTransfer` scheduler against the BBOmix benchmark +blackbox data (105k autoencodix training runs) to produce a small ranked +portfolio of hyperparameter configs per (architecture, dataset-or-"combined", +objective[, budget]), and serializes the result to a static JSON artifact +shipped with the package. + +Generalization note: nothing here is specific to TCGA/SCHC. Each entry in +`BLACKBOX_MANIFEST` below just names one blackbox and which metric plays the +"downstream" role (an aggregate performance score, maximized, final epoch +only) versus the "reconstruction" role (minimized, per-epoch/multi-fidelity) +for that blackbox. Adding coverage for a brand new dataset means adding a +manifest entry pointing at that dataset's own blackbox and its own metric +names -- no other code in this script needs to change. + +Usage: + python benchmarking/tuning/generate_initial_configs.py +""" + +from __future__ import annotations + +import json +import logging +from pathlib import Path +from typing import Any, Dict, List, Optional + +import numpy as np +import pandas as pd +from syne_tune.blackbox_repository.blackbox_tabular import ( + BlackboxTabular, + deserialize as deserialize_tabular, +) +from syne_tune.blackbox_repository.repository import repository_path +from syne_tune.optimizer.schedulers.transfer_learning.transfer_learning_task_evaluation import ( + TransferLearningTaskEvaluations, +) +from syne_tune.config_space import Domain +from syne_tune.optimizer.schedulers.transfer_learning.zero_shot import ZeroShotTransfer + +logging.basicConfig(level=logging.INFO, format="%(message)s") +logger = logging.getLogger("generate_initial_configs") + + +def _patched_sample_random_config(self, config_space: Dict[str, Any]) -> Dict[str, Any]: + """Workaround for a bug in syne-tune==0.16.0's ZeroShotTransfer: it calls + `self.random_state` inside `_create_surrogate_transfer_learning_evaluations` + (triggered by `use_surrogates=True`), which runs *before* `self.random_state` + is ever assigned in `__init__`, raising AttributeError. This lazily creates + and caches the RandomState instead of relying on __init__ having set it. + Dev-only patch, applied only in this generation script -- never shipped.""" + rng = getattr(self, "random_state", None) + if rng is None: + rng = np.random.RandomState(getattr(self, "random_seed", None)) + self.random_state = rng + return { + k: v.sample(random_state=rng) if isinstance(v, Domain) else v + for k, v in config_space.items() + } + + +ZeroShotTransfer._sample_random_config = _patched_sample_random_config + +REPO_ROOT = Path(__file__).resolve().parents[2] +OUTPUT_PATH = REPO_ROOT / "src" / "autoencodix" / "tuning" / "data" / "initial_configs.json" +README_PATH = Path(__file__).resolve().parent / "README.md" + +BUDGET_GRID = [10, 25, 50, 100, 150, 200, 300] +TOP_K_STORED = 10 # ranked configs kept per portfolio leaf + +# Fixed values held constant during the BBOmix sweep (see the BBOmix archive's +# `autoencodix_package_bbomix/benchmarking/configs/search_space.yaml`), merged +# into every proposed config. +FIXED_HPS: Dict[str, Any] = { + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum", +} + +# HP fields the blackbox config space stores as Float (or that a surrogate +# candidate may sample as float) but the Config schema requires as int. +INT_FIELDS = ["n_layers", "batch_size", "latent_dim", "k_filter"] + +# --- manifest --------------------------------------------------------------- +# One entry per (architecture, dataset) blackbox usable as transfer-learning +# source data. This is the only place dataset-specific knowledge lives -- the +# rest of the script is generic over whatever is listed here. +BLACKBOX_MANIFEST: List[Dict[str, Any]] = [ + { + "blackbox_name": f"bbomix_{arch}_{dataset}", + "architecture": arch, + "dataset": dataset, + "downstream_metric": "metric_avg_ml_task_performance", + "reconstruction_metric": "metric_valid_recon_loss", + } + for arch in ("vanillix", "varix", "ontix", "disentanglix") + for dataset in ("tcga", "schc") +] + +_blackbox_cache: Dict[str, Dict[str, BlackboxTabular]] = {} + + +def _load_bbomix_blackbox(name: str) -> Dict[str, BlackboxTabular]: + """Load a locally-cached bbomix_* blackbox directly, bypassing Syne Tune's + registered-blackbox allowlist (bbomix blackboxes are BBOmix-specific, not + part of Syne Tune's own registry).""" + if name not in _blackbox_cache: + _blackbox_cache[name] = deserialize_tabular(repository_path / name) + return _blackbox_cache[name] + + +def _sanitize_hyperparameters(hp_df: pd.DataFrame) -> pd.DataFrame: + out = hp_df.copy() + for col in out.columns: + if pd.api.types.is_integer_dtype(out[col]): + out[col] = out[col].astype(int) + elif pd.api.types.is_float_dtype(out[col]): + out[col] = out[col].astype(float) + else: + out[col] = out[col].astype(str) + return out + + +def _task_evaluations( + bb: BlackboxTabular, metric: str, epoch_idx: Optional[int] +) -> Optional[TransferLearningTaskEvaluations]: + """Build a TransferLearningTaskEvaluations for one blackbox task, sliced at + `epoch_idx` (0-indexed) or the final epoch when `epoch_idx is None`.""" + try: + metric_index = bb.objectives_names.index(metric) + except ValueError: + return None + + evals = bb.objectives_evaluations # (H, S, E, O) + single = evals[..., metric_index : metric_index + 1] + if epoch_idx is None: + sliced = single[:, :, -1:, :] + else: + if epoch_idx >= single.shape[2]: + return None + sliced = single[:, :, epoch_idx : epoch_idx + 1, :] + + if np.all(np.isnan(sliced)): + return None + + return TransferLearningTaskEvaluations( + hyperparameters=_sanitize_hyperparameters(bb.hyperparameters), + configuration_space=bb.configuration_space, + objectives_evaluations=sliced, + objectives_names=[metric], + ) + + +def _build_transfer_evaluations( + entries: List[Dict[str, Any]], + metric_field: str, + epoch_idx: Optional[int] = None, + exclude_task_key: Optional[str] = None, +) -> Dict[str, TransferLearningTaskEvaluations]: + tle: Dict[str, TransferLearningTaskEvaluations] = {} + for entry in entries: + bb_dict = _load_bbomix_blackbox(entry["blackbox_name"]) + metric = entry[metric_field] + for task_name, bb in bb_dict.items(): + task_key = f"{entry['blackbox_name']}/{task_name}" + if task_key == exclude_task_key: + continue + task_eval = _task_evaluations(bb, metric, epoch_idx) + if task_eval is not None: + tle[task_key] = task_eval + return tle + + +def _fit_and_rank( + config_space: Dict[str, Any], + metric: str, + do_minimize: bool, + tle: Dict[str, TransferLearningTaskEvaluations], + num_configs: int = TOP_K_STORED, +) -> List[Dict[str, Any]]: + if not tle: + return [] + scheduler = ZeroShotTransfer( + config_space=config_space, + metric=metric, + do_minimize=do_minimize, + transfer_learning_evaluations=tle, + use_surrogates=True, + ) + configs: List[Dict[str, Any]] = [] + for _ in range(num_configs): + cfg = scheduler.get_config() + if cfg is None: + break + configs.append(dict(cfg)) + return configs + + +def _postprocess(hp: Dict[str, Any], epochs: int) -> Dict[str, Any]: + out = dict(hp) + for field in INT_FIELDS: + if field in out and out[field] is not None: + out[field] = int(round(out[field])) + out.update(FIXED_HPS) + if epochs < FIXED_HPS["epochs"]: + out["epochs"] = epochs + out["checkpoint_interval"] = epochs + return out + + +def _nearest_neighbor_percentile( + bb: BlackboxTabular, + metric: str, + epoch_idx: Optional[int], + do_minimize: bool, + hp: Dict[str, Any], +) -> Optional[float]: + """Approximate how good a recommended config is on a held-out task: find the + nearest real evaluated config (by normalized Euclidean distance in HP + space) and report what percentile of all real configs it beats. + + Informational only -- this is a nearest-neighbor proxy, not an exact + surrogate evaluation of the recommended config.""" + try: + metric_index = bb.objectives_names.index(metric) + except ValueError: + return None + + evals = bb.objectives_evaluations[..., metric_index] # (H, S, E) + idx = evals.shape[2] - 1 if epoch_idx is None else epoch_idx + if idx >= evals.shape[2]: + return None + scores = np.nanmean(evals[:, :, idx], axis=1) # (H,), averaged over seeds + valid = ~np.isnan(scores) + if valid.sum() == 0: + return None + + hp_df = bb.hyperparameters + columns = [c for c in hp_df.columns if c in hp] + if not columns: + return None + ranges = hp_df[columns].max() - hp_df[columns].min() + ranges = ranges.replace(0, 1.0) + norm_df = (hp_df[columns] - hp_df[columns].min()) / ranges + target = np.array([(hp[c] - hp_df[c].min()) / ranges[c] for c in columns]) + dists = np.linalg.norm(norm_df.values - target, axis=1) + dists = np.where(valid, dists, np.inf) + nn_idx = int(np.argmin(dists)) + nn_score = scores[nn_idx] + + valid_scores = scores[valid] + if do_minimize: + percentile = float((valid_scores >= nn_score).mean() * 100) + else: + percentile = float((valid_scores <= nn_score).mean() * 100) + return percentile + + +def _architectures() -> List[str]: + seen = [] + for entry in BLACKBOX_MANIFEST: + if entry["architecture"] not in seen: + seen.append(entry["architecture"]) + return seen + + +def _datasets_for(arch: str) -> List[str]: + return [e["dataset"] for e in BLACKBOX_MANIFEST if e["architecture"] == arch] + + +def run_validation(arch: str, report_lines: List[str]) -> None: + """Leave-one-task-out validation: for each held-out task, refit on the rest + and record the top-1 recommendation's nearest-neighbor percentile on the + held-out task. Informational only -- not asserted in CI.""" + entries = [e for e in BLACKBOX_MANIFEST if e["architecture"] == arch] + config_space = _load_bbomix_blackbox(entries[0]["blackbox_name"])[ + list(_load_bbomix_blackbox(entries[0]["blackbox_name"]))[0] + ].configuration_space + + objective_specs = [("downstream", "downstream_metric", None, False)] + for budget in BUDGET_GRID: + objective_specs.append( + (f"reconstruction@{budget}", "reconstruction_metric", budget - 1, True) + ) + + for label, metric_field, epoch_idx, do_minimize in objective_specs: + percentiles: List[float] = [] + for entry in entries: + bb_dict = _load_bbomix_blackbox(entry["blackbox_name"]) + metric = entry[metric_field] + for task_name, bb in bb_dict.items(): + task_key = f"{entry['blackbox_name']}/{task_name}" + tle = _build_transfer_evaluations( + entries, metric_field, epoch_idx, exclude_task_key=task_key + ) + top = _fit_and_rank( + config_space, metric, do_minimize, tle, num_configs=1 + ) + if not top: + continue + pct = _nearest_neighbor_percentile( + bb, metric, epoch_idx, do_minimize, top[0] + ) + if pct is not None: + percentiles.append(pct) + if percentiles: + msg = ( + f" {label}: mean percentile {np.mean(percentiles):.1f} " + f"(n={len(percentiles)} held-out tasks)" + ) + else: + msg = f" {label}: no held-out evaluations available" + logger.info(msg) + report_lines.append(msg) + + +def build_portfolios_for_architecture(arch: str) -> Dict[str, Any]: + entries = [e for e in BLACKBOX_MANIFEST if e["architecture"] == arch] + first_bb = _load_bbomix_blackbox(entries[0]["blackbox_name"]) + config_space = first_bb[list(first_bb)[0]].configuration_space + + result: Dict[str, Any] = {} + + def _downstream_portfolio(scoped_entries): + tle = _build_transfer_evaluations(scoped_entries, "downstream_metric") + raw = _fit_and_rank(config_space, "metric_avg_ml_task_performance", False, tle) + return [_postprocess(hp, epochs=FIXED_HPS["epochs"]) for hp in raw] + + def _reconstruction_portfolio(scoped_entries): + out = {} + for budget in BUDGET_GRID: + tle = _build_transfer_evaluations( + scoped_entries, "reconstruction_metric", epoch_idx=budget - 1 + ) + raw = _fit_and_rank(config_space, "metric_valid_recon_loss", True, tle) + out[str(budget)] = [_postprocess(hp, epochs=budget) for hp in raw] + return out + + result["combined"] = { + "downstream": _downstream_portfolio(entries), + "reconstruction": _reconstruction_portfolio(entries), + } + for dataset in _datasets_for(arch): + scoped = [e for e in entries if e["dataset"] == dataset] + result[dataset] = { + "downstream": _downstream_portfolio(scoped), + "reconstruction": _reconstruction_portfolio(scoped), + } + return result + + +def main() -> None: + report_lines = ["# Initial-config generation report", ""] + artifact: Dict[str, Any] = {} + + for arch in _architectures(): + logger.info("=== %s ===", arch) + report_lines.append(f"## {arch}") + run_validation(arch, report_lines) + artifact[arch] = build_portfolios_for_architecture(arch) + report_lines.append("") + + OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True) + OUTPUT_PATH.write_text(json.dumps(artifact, indent=2)) + logger.info("Wrote %s", OUTPUT_PATH) + + README_PATH.write_text("\n".join(report_lines) + "\n") + logger.info("Wrote %s", README_PATH) + + +if __name__ == "__main__": + main() diff --git a/mkdocs.yml b/mkdocs.yml index 07a851e0..080a5556 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -23,6 +23,7 @@ nav: - Explain Step: tutorials/DeepDives/ExplainStep.ipynb - Hyperparameter Optimization: tutorials/DeepDives/HyperparameterOptimizationTutorial.ipynb - "Hyperparameter Optimization (Optuna)": tutorials/DeepDives/HyperparameterOptimizationOptunaTutorial.ipynb + - Propose Initial Config: tutorials/DeepDives/ProposeInitialConfigTutorial.ipynb - Using Pre-Trained Models: tutorials/DeepDives/UsingPreTrainedModels.ipynb - Memory-Efficient Saving: tutorials/DeepDives/MemoryEfficientSaving.ipynb - Developer Guide: tutorials/DevGuide.ipynb diff --git a/pyproject.toml b/pyproject.toml index 981a8ff1..6bfd53bb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -67,12 +67,22 @@ dev = [ "mkdocs-literate-nav>=0.6.2", "mkdocs-section-index>=0.3.10", "torch-tb-profiler>=0.4.3", + "syne-tune>=0.14.2", + "build>=1.2.1", ] [build-system] requires = ["hatchling"] build-backend = "hatchling.build" +[tool.hatch.build.targets.wheel] +packages = ["src/autoencodix"] + +[tool.pytest.ini_options] +markers = [ + "slow: builds/installs a wheel, run explicitly with -m slow", +] + [tool.ty.rules] [tool.ty.src] exclude = ["src/autoencodix/utils/feature_importance.py", "**/.ipynb_checkpoints/**",] diff --git a/src/autoencodix/__init__.py b/src/autoencodix/__init__.py index c0235eb2..103b1c40 100644 --- a/src/autoencodix/__init__.py +++ b/src/autoencodix/__init__.py @@ -14,6 +14,7 @@ from .xmodalix import XModalix from .imagix import Imagix from .maskix import Maskix +from .tuning import propose_initial_config __all__ = [ "Vanillix", @@ -24,4 +25,5 @@ "Imagix", "Disentanglix", "Maskix", + "propose_initial_config", ] diff --git a/src/autoencodix/tuning/__init__.py b/src/autoencodix/tuning/__init__.py new file mode 100644 index 00000000..70dfccf7 --- /dev/null +++ b/src/autoencodix/tuning/__init__.py @@ -0,0 +1,3 @@ +from ._propose import propose_initial_config + +__all__ = ["propose_initial_config"] diff --git a/src/autoencodix/tuning/_propose.py b/src/autoencodix/tuning/_propose.py new file mode 100644 index 00000000..6f4ac166 --- /dev/null +++ b/src/autoencodix/tuning/_propose.py @@ -0,0 +1,196 @@ +"""Static, transfer-learning-derived initial-config proposals for autoencodix models. + +The portfolios returned here were computed *offline* (see +``benchmarking/tuning/generate_initial_configs.py``) by fitting Syne Tune's +``ZeroShotTransfer`` scheduler against the BBOmix benchmark (105k training runs +across vanillix/varix/ontix/disentanglix). Since a caller of +:func:`propose_initial_config` has zero evaluations of their own yet, there is no +live optimizer state to maintain at call time -- this module is a plain JSON +lookup plus Pydantic validation, and never imports ``syne-tune``. + +Optional future extension (not implemented here): if a caller wants the proposal +refined using a handful of their *own* live training runs, that is a distinct +"suggest next trial" mode requiring a real warm-started online scheduler +(e.g. Syne Tune's ``BoundingBox`` / ``QuantileBasedSurrogateSearcher``) and +``syne-tune`` as a genuine runtime dependency (a future ``autoencodix[tuning]`` +extra). +""" + +import json +import warnings +from importlib import resources +from typing import Any, Dict, List, Literal, Optional, Union + +from autoencodix.configs.default_config import DefaultConfig +from autoencodix.configs.disentanglix_config import DisentanglixConfig +from autoencodix.configs.maskix_config import MaskixConfig +from autoencodix.configs.ontix_config import OntixConfig +from autoencodix.configs.stackix_config import StackixConfig +from autoencodix.configs.vanillix_config import VanillixConfig +from autoencodix.configs.varix_config import VarixConfig +from autoencodix.configs.xmodalix_config import XModalixConfig + +Objective = Literal["downstream", "reconstruction"] + +# Every architecture that *has* a dedicated Config class, used only as the +# fallback target for `allow_fallback_to_defaults=True`. Whether an architecture +# additionally has a BBOmix-derived portfolio is determined dynamically from the +# loaded artifact (see `_covered_architectures`), not hardcoded here. +_CONFIG_CLASSES: Dict[str, type] = { + "vanillix": VanillixConfig, + "varix": VarixConfig, + "ontix": OntixConfig, + "disentanglix": DisentanglixConfig, + "stackix": StackixConfig, + "xmodalix": XModalixConfig, + "maskix": MaskixConfig, +} + +_ARTIFACT_PACKAGE = "autoencodix.tuning.data" +_ARTIFACT_FILENAME = "initial_configs.json" + +_artifact_cache: Optional[Dict[str, Any]] = None + + +def _load_artifact() -> Dict[str, Any]: + global _artifact_cache + if _artifact_cache is None: + data_text = ( + resources.files(_ARTIFACT_PACKAGE) + .joinpath(_ARTIFACT_FILENAME) + .read_text(encoding="utf-8") + ) + _artifact_cache = json.loads(data_text) + return _artifact_cache + + +def _covered_architectures(artifact: Dict[str, Any]) -> List[str]: + return sorted(set(artifact) & set(_CONFIG_CLASSES)) + + +def _resolve_scope( + artifact: Dict[str, Any], architecture: str, arch_key: str, dataset: Optional[str] +) -> Dict[str, Any]: + arch_entry = artifact[arch_key] + scope_key = "combined" if dataset is None else dataset + if scope_key not in arch_entry: + available = sorted(k for k in arch_entry if k != "combined") + raise ValueError( + f"Unknown dataset {dataset!r} for architecture {architecture!r}. " + f"Available datasets: {available}. Omit `dataset` (or pass None) to " + "use the combined, cross-dataset portfolio -- the recommended default " + "for a new dataset that wasn't part of the BBOmix benchmark." + ) + return arch_entry[scope_key] + + +def propose_initial_config( + architecture: str, + dataset: Optional[str] = None, + objective: Objective = "downstream", + budget_epochs: Optional[int] = None, + top_k: int = 1, + allow_fallback_to_defaults: bool = False, + **overrides: Any, +) -> Union[DefaultConfig, List[DefaultConfig]]: + """Propose a strong initial config for an autoencodix architecture. + + The proposal is a ranked portfolio entry derived offline from the BBOmix + benchmark via zero-shot transfer learning -- not a config tuned on any + evaluations of your own. + + Args: + architecture: Model architecture, e.g. ``"varix"`` (case-insensitive). + dataset: Restrict the source portfolio to one BBOmix dataset (whatever + datasets happen to be in the shipped artifact, e.g. ``"tcga"`` or + ``"schc"``). Defaults to ``None``, which uses the ``"combined"`` + portfolio pooling all available source tasks -- this is the + recommended default, since it is the one expected to generalize to + a dataset that wasn't part of the benchmark. + objective: ``"downstream"`` (maximize aggregate downstream task + performance, final-epoch only) or ``"reconstruction"`` (minimize + reconstruction loss, with a `budget_epochs` fidelity axis). + budget_epochs: Only valid for ``objective="reconstruction"``. Snapped to + the nearest budget actually present in the artifact (a `UserWarning` + is emitted on snap); defaults to the largest available budget + (full training length) when omitted. + top_k: Number of ranked configs to return. Returns a single config when + ``top_k=1`` (the default), otherwise a list. + allow_fallback_to_defaults: If the architecture has no BBOmix-derived + portfolio but does have a Config class, emit a `UserWarning` and + return that class's plain schema defaults instead of raising. + **overrides: Applied on top of the proposed hyperparameters before + constructing the Config object; invalid overrides raise + `pydantic.ValidationError`. + + Returns: + A single Config instance, or a list of `top_k` Config instances. + + Raises: + ValueError: Unknown/unsupported architecture, unknown dataset, or an + invalid combination of `objective`/`budget_epochs`. + """ + artifact = _load_artifact() + arch_key = architecture.strip().lower() + covered = _covered_architectures(artifact) + + if arch_key not in covered: + if allow_fallback_to_defaults and arch_key in _CONFIG_CLASSES: + warnings.warn( + f"No BBOmix-derived portfolio for architecture {architecture!r}; " + f"falling back to {_CONFIG_CLASSES[arch_key].__name__} schema " + "defaults. Supported architectures with a portfolio: " + f"{covered}.", + UserWarning, + stacklevel=2, + ) + return _CONFIG_CLASSES[arch_key](**overrides) + raise ValueError( + f"Unsupported architecture {architecture!r}. propose_initial_config " + f"has a BBOmix-derived portfolio for: {covered}. Pass " + "allow_fallback_to_defaults=True to fall back to plain schema " + "defaults for any other architecture with a Config class." + ) + + if objective not in ("downstream", "reconstruction"): + raise ValueError( + f"objective must be 'downstream' or 'reconstruction', got {objective!r}." + ) + + if objective == "downstream" and budget_epochs is not None: + raise ValueError( + "budget_epochs is only meaningful for objective='reconstruction' -- " + "there is no per-epoch signal for downstream performance in the " + "benchmark data, so it has nothing to act on here." + ) + + if top_k < 1: + raise ValueError(f"top_k must be >= 1, got {top_k}.") + + scope = _resolve_scope(artifact, architecture, arch_key, dataset) + + if objective == "downstream": + candidates = scope["downstream"] + else: + recon = scope["reconstruction"] + available_budgets = sorted(int(b) for b in recon) + if budget_epochs is None: + chosen_budget = max(available_budgets) + else: + chosen_budget = min( + available_budgets, key=lambda b: abs(b - budget_epochs) + ) + if chosen_budget != budget_epochs: + warnings.warn( + f"budget_epochs={budget_epochs} is not one of the available " + f"budgets {available_budgets}; snapped to {chosen_budget}.", + UserWarning, + stacklevel=2, + ) + candidates = recon[str(chosen_budget)] + + selected = candidates[: min(top_k, len(candidates))] + config_cls = _CONFIG_CLASSES[arch_key] + configs = [config_cls(**{**hp, **overrides}) for hp in selected] + + return configs[0] if top_k == 1 else configs diff --git a/src/autoencodix/tuning/data/__init__.py b/src/autoencodix/tuning/data/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/autoencodix/tuning/data/initial_configs.json b/src/autoencodix/tuning/data/initial_configs.json new file mode 100644 index 00000000..ed4e1897 --- /dev/null +++ b/src/autoencodix/tuning/data/initial_configs.json @@ -0,0 +1,13690 @@ +{ + "vanillix": { + "combined": { + "downstream": [ + { + "k_filter": 1057, + "n_layers": 2, + "enc_factor": 2.152078905725987, + "batch_size": 35, + "learning_rate": 3.398834630240624e-05, + "drop_p": 0.2709383296812686, + "weight_decay": 2.6694253697765106e-05, + "latent_dim": 37, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2889, + "n_layers": 2, + "enc_factor": 3.5029845228882013, + "batch_size": 122, + "learning_rate": 3.852032671739199e-05, + "drop_p": 0.2296423978130885, + "weight_decay": 2.2651038370486676e-05, + "latent_dim": 56, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1274, + "n_layers": 4, + "enc_factor": 1.5281140487137983, + "batch_size": 86, + "learning_rate": 9.214685527730229e-05, + "drop_p": 0.47910682226398227, + "weight_decay": 4.284387799885439e-05, + "latent_dim": 60, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2573, + "n_layers": 4, + "enc_factor": 3.695190793644602, + "batch_size": 218, + "learning_rate": 0.006245526688192974, + "drop_p": 0.6435749436404308, + "weight_decay": 0.00017258850979433234, + "latent_dim": 4, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3931, + "n_layers": 2, + "enc_factor": 2.195817776085362, + "batch_size": 63, + "learning_rate": 0.00026080014820992415, + "drop_p": 0.016041442539638805, + "weight_decay": 0.008811190690740892, + "latent_dim": 32, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 461, + "n_layers": 4, + "enc_factor": 1.3299471914268706, + "batch_size": 183, + "learning_rate": 0.0005445149651197089, + "drop_p": 0.21021229522722343, + "weight_decay": 0.0002684833726666874, + "latent_dim": 58, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3637, + "n_layers": 2, + "enc_factor": 1.2746373770583421, + "batch_size": 108, + "learning_rate": 0.0004764800594242264, + "drop_p": 0.2617759417538456, + "weight_decay": 0.0002703451597748767, + "latent_dim": 58, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1471, + "n_layers": 2, + "enc_factor": 2.2986773120843056, + "batch_size": 180, + "learning_rate": 0.007498582196973872, + "drop_p": 0.7993137321453229, + "weight_decay": 0.0004555855742767654, + "latent_dim": 19, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2258, + "n_layers": 3, + "enc_factor": 3.4593168946675217, + "batch_size": 175, + "learning_rate": 2.37542213753357e-05, + "drop_p": 0.8965136566307839, + "weight_decay": 2.771123489663411e-05, + "latent_dim": 55, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3147, + "n_layers": 2, + "enc_factor": 1.5639306220329332, + "batch_size": 187, + "learning_rate": 0.018475011015956003, + "drop_p": 0.14266537339758142, + "weight_decay": 0.0019198575904282743, + "latent_dim": 46, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 1572, + "n_layers": 3, + "enc_factor": 3.4060598265133613, + "batch_size": 49, + "learning_rate": 0.0002818853357593483, + "drop_p": 0.16198594313661466, + "weight_decay": 0.0032633476837079425, + "latent_dim": 33, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 506, + "n_layers": 3, + "enc_factor": 1.2485922194336156, + "batch_size": 112, + "learning_rate": 0.0002921844447384468, + "drop_p": 0.41769959907672166, + "weight_decay": 1.893562793448723e-05, + "latent_dim": 62, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 321, + "n_layers": 4, + "enc_factor": 3.145417897172496, + "batch_size": 208, + "learning_rate": 0.0017466205922187397, + "drop_p": 0.14915340408401098, + "weight_decay": 1.3204877623718659e-05, + "latent_dim": 29, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 148, + "n_layers": 3, + "enc_factor": 3.9900106095722268, + "batch_size": 114, + "learning_rate": 0.0009766686382276456, + "drop_p": 0.6773423041407111, + "weight_decay": 0.00042099745648936995, + "latent_dim": 47, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1341, + "n_layers": 3, + "enc_factor": 2.601029855409961, + "batch_size": 56, + "learning_rate": 0.04231056069861028, + "drop_p": 0.5998380556522543, + "weight_decay": 0.0022041099714447516, + "latent_dim": 47, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 250, + "n_layers": 3, + "enc_factor": 1.2308195509010786, + "batch_size": 199, + "learning_rate": 0.03863658036222211, + "drop_p": 0.1550978383239007, + "weight_decay": 3.382489255726729e-05, + "latent_dim": 35, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 951, + "n_layers": 3, + "enc_factor": 2.7392877200239734, + "batch_size": 56, + "learning_rate": 0.0024768577992769795, + "drop_p": 0.44039298193072623, + "weight_decay": 2.3794877560923966e-05, + "latent_dim": 55, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2949, + "n_layers": 2, + "enc_factor": 1.8007156234407193, + "batch_size": 248, + "learning_rate": 0.08582710488284241, + "drop_p": 0.8370063813991183, + "weight_decay": 2.1675003680303663e-05, + "latent_dim": 43, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3011, + "n_layers": 3, + "enc_factor": 2.7839853088753648, + "batch_size": 149, + "learning_rate": 0.0037462597573937233, + "drop_p": 0.17509611105054518, + "weight_decay": 0.02163078003489198, + "latent_dim": 18, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 156, + "n_layers": 2, + "enc_factor": 1.4704045020137522, + "batch_size": 48, + "learning_rate": 2.5833592325649448e-05, + "drop_p": 0.12946064311765873, + "weight_decay": 0.07287173370390447, + "latent_dim": 38, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 267, + "n_layers": 3, + "enc_factor": 2.957045069422466, + "batch_size": 52, + "learning_rate": 5.245517671202235e-05, + "drop_p": 0.29828933526020873, + "weight_decay": 0.027004233393291086, + "latent_dim": 28, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2932, + "n_layers": 2, + "enc_factor": 2.9157014464672604, + "batch_size": 57, + "learning_rate": 0.00017400724971952463, + "drop_p": 0.20208817049706296, + "weight_decay": 1.4478647690207336e-05, + "latent_dim": 15, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 158, + "n_layers": 3, + "enc_factor": 1.7709851347022536, + "batch_size": 255, + "learning_rate": 0.0015311580416133206, + "drop_p": 0.46469033146090283, + "weight_decay": 0.0027141180477340114, + "latent_dim": 60, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3179, + "n_layers": 3, + "enc_factor": 2.0175363482523307, + "batch_size": 213, + "learning_rate": 5.011232175595331e-05, + "drop_p": 0.5095480995854471, + "weight_decay": 3.347394015692424e-05, + "latent_dim": 9, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2341, + "n_layers": 3, + "enc_factor": 1.5782841656461484, + "batch_size": 140, + "learning_rate": 0.0035822571738102532, + "drop_p": 0.8778131536135203, + "weight_decay": 0.00019907716741647842, + "latent_dim": 62, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 483, + "n_layers": 4, + "enc_factor": 1.9046460472958593, + "batch_size": 228, + "learning_rate": 0.0011519744718477172, + "drop_p": 0.6452576251056377, + "weight_decay": 0.0035617196569474687, + "latent_dim": 33, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 134, + "n_layers": 3, + "enc_factor": 2.031652604405886, + "batch_size": 100, + "learning_rate": 0.002347803980952823, + "drop_p": 0.3987546443019499, + "weight_decay": 1.129550478679498e-05, + "latent_dim": 44, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3404, + "n_layers": 2, + "enc_factor": 2.612618918084566, + "batch_size": 51, + "learning_rate": 0.00014078086573298705, + "drop_p": 0.11067706655596798, + "weight_decay": 0.018499956596635128, + "latent_dim": 44, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2210, + "n_layers": 3, + "enc_factor": 1.1720885093283973, + "batch_size": 135, + "learning_rate": 0.0002445414182909112, + "drop_p": 0.044379264621135776, + "weight_decay": 0.0002926178365768716, + "latent_dim": 10, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 482, + "n_layers": 2, + "enc_factor": 3.035352786230564, + "batch_size": 203, + "learning_rate": 0.00134903362121533, + "drop_p": 0.13978999722967125, + "weight_decay": 0.0001440702224131526, + "latent_dim": 21, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 155, + "n_layers": 3, + "enc_factor": 1.435403385419959, + "batch_size": 62, + "learning_rate": 0.0008800219672079395, + "drop_p": 0.2306595187728538, + "weight_decay": 0.0004191644313938903, + "latent_dim": 29, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3769, + "n_layers": 3, + "enc_factor": 3.909471747634616, + "batch_size": 113, + "learning_rate": 0.0001874435184590846, + "drop_p": 0.8706484308283067, + "weight_decay": 0.0006981361123521049, + "latent_dim": 42, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2806, + "n_layers": 2, + "enc_factor": 2.2609317431906293, + "batch_size": 223, + "learning_rate": 0.0007531950249973592, + "drop_p": 0.41217192259140917, + "weight_decay": 4.1825355068829584e-05, + "latent_dim": 19, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1094, + "n_layers": 4, + "enc_factor": 1.7680290286789564, + "batch_size": 218, + "learning_rate": 0.0022213733505362133, + "drop_p": 0.4412382045493697, + "weight_decay": 0.029549241412746414, + "latent_dim": 3, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1721, + "n_layers": 3, + "enc_factor": 3.462037346405688, + "batch_size": 231, + "learning_rate": 0.0035597003523291856, + "drop_p": 0.28646177192278155, + "weight_decay": 2.67709384459624e-05, + "latent_dim": 22, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2594, + "n_layers": 4, + "enc_factor": 1.1542348846344754, + "batch_size": 60, + "learning_rate": 0.00012366821587407367, + "drop_p": 0.3675352490760574, + "weight_decay": 0.0010506298887320508, + "latent_dim": 49, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 221, + "n_layers": 3, + "enc_factor": 1.2347065278384064, + "batch_size": 114, + "learning_rate": 0.00012639641872274536, + "drop_p": 0.022467722222972032, + "weight_decay": 0.00016479163289368891, + "latent_dim": 35, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3547, + "n_layers": 4, + "enc_factor": 3.477335682205254, + "batch_size": 126, + "learning_rate": 0.000620464075865609, + "drop_p": 0.8169716637276584, + "weight_decay": 0.0011663702300336329, + "latent_dim": 46, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2306, + "n_layers": 4, + "enc_factor": 2.2653190726474954, + "batch_size": 119, + "learning_rate": 0.00783353626073285, + "drop_p": 0.4345410737037513, + "weight_decay": 0.042902577354641994, + "latent_dim": 30, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2604, + "n_layers": 3, + "enc_factor": 2.9126197382847634, + "batch_size": 204, + "learning_rate": 3.510349356684033e-05, + "drop_p": 0.23101829112168162, + "weight_decay": 0.00013289926762791084, + "latent_dim": 57, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 157, + "n_layers": 4, + "enc_factor": 3.8774868745968387, + "batch_size": 163, + "learning_rate": 0.0007118612490151947, + "drop_p": 0.5680032110444446, + "weight_decay": 1.5571209035670975e-05, + "latent_dim": 8, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3108, + "n_layers": 4, + "enc_factor": 1.6057129817849196, + "batch_size": 153, + "learning_rate": 1.7675703549685415e-05, + "drop_p": 0.6921856131507858, + "weight_decay": 0.0012816118720483354, + "latent_dim": 2, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1849, + "n_layers": 3, + "enc_factor": 1.7356676445459698, + "batch_size": 184, + "learning_rate": 0.021546266842542874, + "drop_p": 0.7853089097410836, + "weight_decay": 0.014949984228313552, + "latent_dim": 40, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2444, + "n_layers": 3, + "enc_factor": 3.538878694415845, + "batch_size": 101, + "learning_rate": 1.3963463350751356e-05, + "drop_p": 0.15585348738340257, + "weight_decay": 0.005177769736803514, + "latent_dim": 52, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 769, + "n_layers": 2, + "enc_factor": 2.0684094712293235, + "batch_size": 98, + "learning_rate": 0.007983344730115607, + "drop_p": 0.5411393396671462, + "weight_decay": 0.0008224137633406225, + "latent_dim": 19, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 217, + "n_layers": 2, + "enc_factor": 1.4871986304779226, + "batch_size": 244, + "learning_rate": 0.000767858206513676, + "drop_p": 0.02290122713089804, + "weight_decay": 1.3781550358490488e-05, + "latent_dim": 3, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 247, + "n_layers": 4, + "enc_factor": 2.8463510773166734, + "batch_size": 142, + "learning_rate": 0.00904895771719461, + "drop_p": 0.372205269020563, + "weight_decay": 0.02870543167993155, + "latent_dim": 17, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3893, + "n_layers": 3, + "enc_factor": 2.0930941801831375, + "batch_size": 84, + "learning_rate": 0.00014746003546421097, + "drop_p": 0.6256475796190211, + "weight_decay": 0.00038465950084164456, + "latent_dim": 43, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2578, + "n_layers": 3, + "enc_factor": 3.5979883207642067, + "batch_size": 88, + "learning_rate": 0.001263304188709255, + "drop_p": 0.254503360009319, + "weight_decay": 0.0017790248305444207, + "latent_dim": 8, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 467, + "n_layers": 4, + "enc_factor": 1.861027985817484, + "batch_size": 101, + "learning_rate": 0.0007858837770725348, + "drop_p": 0.8306728401063955, + "weight_decay": 0.003430400515269999, + "latent_dim": 63, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 388, + "n_layers": 2, + "enc_factor": 3.066565693307429, + "batch_size": 202, + "learning_rate": 4.1929021397281195e-05, + "drop_p": 0.2701695863257791, + "weight_decay": 0.000215792311292893, + "latent_dim": 5, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 335, + "n_layers": 3, + "enc_factor": 3.985266329349142, + "batch_size": 63, + "learning_rate": 0.05084935777405841, + "drop_p": 0.7152469065161452, + "weight_decay": 0.00012663152835800707, + "latent_dim": 58, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 195, + "n_layers": 3, + "enc_factor": 2.0651860030694897, + "batch_size": 101, + "learning_rate": 0.000554792700920719, + "drop_p": 0.8784093145764978, + "weight_decay": 0.006089772726245855, + "latent_dim": 61, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 198, + "n_layers": 3, + "enc_factor": 1.5448111992118798, + "batch_size": 81, + "learning_rate": 0.015123314341274277, + "drop_p": 0.43655784207319087, + "weight_decay": 0.04821224655275261, + "latent_dim": 59, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3243, + "n_layers": 3, + "enc_factor": 2.056552609455822, + "batch_size": 94, + "learning_rate": 0.002211429881922667, + "drop_p": 0.008464966702397825, + "weight_decay": 1.2023492933792354e-05, + "latent_dim": 9, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3998, + "n_layers": 2, + "enc_factor": 1.483535248485601, + "batch_size": 139, + "learning_rate": 0.03233288931211919, + "drop_p": 0.24792770937004024, + "weight_decay": 0.0006247699962436966, + "latent_dim": 58, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3150, + "n_layers": 4, + "enc_factor": 1.5710706247118857, + "batch_size": 103, + "learning_rate": 0.059827906256008055, + "drop_p": 0.4579231445692534, + "weight_decay": 0.00406919639016748, + "latent_dim": 12, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1971, + "n_layers": 4, + "enc_factor": 3.350801277159774, + "batch_size": 139, + "learning_rate": 2.5283104879750086e-05, + "drop_p": 0.3619808175132218, + "weight_decay": 0.07418509420320535, + "latent_dim": 50, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1934, + "n_layers": 2, + "enc_factor": 3.980252876386804, + "batch_size": 99, + "learning_rate": 0.0016805489878361649, + "drop_p": 0.7407110416602138, + "weight_decay": 5.802417499508185e-05, + "latent_dim": 7, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1274, + "n_layers": 3, + "enc_factor": 3.3961305710697447, + "batch_size": 119, + "learning_rate": 3.775117854098204e-05, + "drop_p": 0.1900766425911771, + "weight_decay": 0.00040987645816077125, + "latent_dim": 10, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 1480, + "n_layers": 3, + "enc_factor": 2.463216768446826, + "batch_size": 181, + "learning_rate": 0.0023122232495477063, + "drop_p": 0.41593174704183944, + "weight_decay": 1.4669063229893497e-05, + "latent_dim": 31, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 377, + "n_layers": 3, + "enc_factor": 1.6195493539890777, + "batch_size": 177, + "learning_rate": 0.00019746366842131324, + "drop_p": 0.6347768049981378, + "weight_decay": 0.00215667253263319, + "latent_dim": 34, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 148, + "n_layers": 4, + "enc_factor": 1.9503820039022308, + "batch_size": 93, + "learning_rate": 0.0006399102198923845, + "drop_p": 0.47831179361211784, + "weight_decay": 0.003186634937034622, + "latent_dim": 34, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 4019, + "n_layers": 3, + "enc_factor": 3.9420076838592233, + "batch_size": 91, + "learning_rate": 0.0006077269324996168, + "drop_p": 0.6397767811353838, + "weight_decay": 1.0286439216826345e-05, + "latent_dim": 11, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3639, + "n_layers": 4, + "enc_factor": 1.312317895645106, + "batch_size": 44, + "learning_rate": 3.361786416572306e-05, + "drop_p": 0.2644670168737151, + "weight_decay": 0.00019669170453197565, + "latent_dim": 10, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1826, + "n_layers": 4, + "enc_factor": 2.467902701344186, + "batch_size": 106, + "learning_rate": 0.04946222507967335, + "drop_p": 0.513221754540624, + "weight_decay": 0.006327378145398287, + "latent_dim": 31, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3810, + "n_layers": 2, + "enc_factor": 3.1473510564458382, + "batch_size": 208, + "learning_rate": 0.00014137146623312342, + "drop_p": 0.33033106566958376, + "weight_decay": 8.320424037026861e-05, + "latent_dim": 59, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 163, + "n_layers": 3, + "enc_factor": 2.8563671005482525, + "batch_size": 209, + "learning_rate": 0.00028592821274442116, + "drop_p": 0.15639053505067674, + "weight_decay": 0.00011764055055644763, + "latent_dim": 62, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1084, + "n_layers": 3, + "enc_factor": 2.416860328059078, + "batch_size": 78, + "learning_rate": 2.5837267917712013e-05, + "drop_p": 0.10544095822722159, + "weight_decay": 0.06160735934058077, + "latent_dim": 59, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 4086, + "n_layers": 4, + "enc_factor": 3.0007411550577126, + "batch_size": 249, + "learning_rate": 0.0003481698787832804, + "drop_p": 0.522565880035101, + "weight_decay": 0.0009521149952859269, + "latent_dim": 48, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 158, + "n_layers": 4, + "enc_factor": 2.836593436937239, + "batch_size": 248, + "learning_rate": 1.465627730897283e-05, + "drop_p": 0.15759231151410566, + "weight_decay": 1.3668640608096819e-05, + "latent_dim": 36, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3111, + "n_layers": 2, + "enc_factor": 1.743808631035582, + "batch_size": 175, + "learning_rate": 0.00023184939569675497, + "drop_p": 0.32559990425613566, + "weight_decay": 0.00016954626127154012, + "latent_dim": 47, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 858, + "n_layers": 3, + "enc_factor": 3.2971655123890735, + "batch_size": 225, + "learning_rate": 8.533160799839321e-05, + "drop_p": 0.7942202522493338, + "weight_decay": 0.00016074812239200964, + "latent_dim": 5, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2576, + "n_layers": 4, + "enc_factor": 2.2906279489787034, + "batch_size": 102, + "learning_rate": 0.007176030035428371, + "drop_p": 0.32490112910706165, + "weight_decay": 0.0024347700693591883, + "latent_dim": 27, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1412, + "n_layers": 4, + "enc_factor": 3.8484606591164536, + "batch_size": 112, + "learning_rate": 9.43815678399286e-05, + "drop_p": 0.2734227648547467, + "weight_decay": 0.019447049317147757, + "latent_dim": 49, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3798, + "n_layers": 3, + "enc_factor": 1.9766711105354198, + "batch_size": 68, + "learning_rate": 0.004628401873444844, + "drop_p": 0.13017712247539862, + "weight_decay": 0.00017413119998065148, + "latent_dim": 44, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2655, + "n_layers": 3, + "enc_factor": 2.111853012097466, + "batch_size": 254, + "learning_rate": 2.4889345334460296e-05, + "drop_p": 0.8099985397795543, + "weight_decay": 3.550015095417974e-05, + "latent_dim": 44, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 214, + "n_layers": 3, + "enc_factor": 3.8144358499230133, + "batch_size": 149, + "learning_rate": 0.0002552066496556335, + "drop_p": 0.02761519284148154, + "weight_decay": 0.05994171831267269, + "latent_dim": 18, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1541, + "n_layers": 3, + "enc_factor": 2.580186427517715, + "batch_size": 69, + "learning_rate": 0.07457477065618713, + "drop_p": 0.11685522653217588, + "weight_decay": 0.001233534754325652, + "latent_dim": 11, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 323, + "n_layers": 3, + "enc_factor": 3.848069766389156, + "batch_size": 65, + "learning_rate": 0.000549722345371549, + "drop_p": 0.725822850319277, + "weight_decay": 1.1006693364033532e-05, + "latent_dim": 10, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + }, + "tcga": { + "downstream": [ + { + "k_filter": 1292, + "n_layers": 2, + "enc_factor": 1.3460624144563202, + "batch_size": 51, + "learning_rate": 0.0007414429768528468, + "drop_p": 0.012192958406232112, + "weight_decay": 0.00012669761743836676, + "latent_dim": 42, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 169, + "n_layers": 4, + "enc_factor": 2.802855556516733, + "batch_size": 65, + "learning_rate": 0.007010328632694202, + "drop_p": 0.11881294109147464, + "weight_decay": 0.0018297357374060755, + "latent_dim": 14, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3441, + "n_layers": 2, + "enc_factor": 2.251972963658628, + "batch_size": 179, + "learning_rate": 0.0030061319011881584, + "drop_p": 0.03333802332828039, + "weight_decay": 0.0005381145654286462, + "latent_dim": 42, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1076, + "n_layers": 2, + "enc_factor": 1.9454105914701827, + "batch_size": 189, + "learning_rate": 0.0005372221494590712, + "drop_p": 0.05904991488025011, + "weight_decay": 0.002087491281129277, + "latent_dim": 43, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2190, + "n_layers": 4, + "enc_factor": 3.3171108545027415, + "batch_size": 180, + "learning_rate": 0.00018459692992031624, + "drop_p": 0.6627732196122816, + "weight_decay": 0.002773988917668377, + "latent_dim": 7, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2553, + "n_layers": 3, + "enc_factor": 1.83235513672923, + "batch_size": 129, + "learning_rate": 6.29722105765051e-05, + "drop_p": 0.0057142883511944855, + "weight_decay": 4.340094145947266e-05, + "latent_dim": 45, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3999, + "n_layers": 4, + "enc_factor": 2.310294640537837, + "batch_size": 60, + "learning_rate": 0.0038576518242124784, + "drop_p": 0.8089358510467284, + "weight_decay": 0.0001819806927423535, + "latent_dim": 6, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1429, + "n_layers": 3, + "enc_factor": 3.894700318569622, + "batch_size": 235, + "learning_rate": 0.009683104974579521, + "drop_p": 0.09011454634979843, + "weight_decay": 0.06861707376920012, + "latent_dim": 34, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2628, + "n_layers": 3, + "enc_factor": 1.8739571551432233, + "batch_size": 251, + "learning_rate": 6.035024580055269e-05, + "drop_p": 0.36567005273638725, + "weight_decay": 0.0001117258277859011, + "latent_dim": 61, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 4010, + "n_layers": 4, + "enc_factor": 2.47117220897723, + "batch_size": 193, + "learning_rate": 0.00011828418301516813, + "drop_p": 0.7847790489445673, + "weight_decay": 0.00025682998901478796, + "latent_dim": 61, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 183, + "n_layers": 3, + "enc_factor": 3.402581841715142, + "batch_size": 133, + "learning_rate": 0.0034787711234806674, + "drop_p": 0.26298722906498434, + "weight_decay": 0.010925368460028841, + "latent_dim": 8, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 385, + "n_layers": 3, + "enc_factor": 3.0689263223935277, + "batch_size": 100, + "learning_rate": 0.04985616709841353, + "drop_p": 0.8947930572633956, + "weight_decay": 0.0837998158967391, + "latent_dim": 51, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 308, + "n_layers": 4, + "enc_factor": 1.2991682849720454, + "batch_size": 129, + "learning_rate": 0.03120924895825557, + "drop_p": 0.09773135730247898, + "weight_decay": 8.001095508754165e-05, + "latent_dim": 50, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 811, + "n_layers": 3, + "enc_factor": 1.3184573068855605, + "batch_size": 247, + "learning_rate": 0.009665484792906428, + "drop_p": 0.010947116056159755, + "weight_decay": 0.06660730154732292, + "latent_dim": 33, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3939, + "n_layers": 3, + "enc_factor": 3.1052079818514073, + "batch_size": 99, + "learning_rate": 0.028211143023146104, + "drop_p": 0.2562778263072429, + "weight_decay": 0.015459402711885246, + "latent_dim": 55, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3745, + "n_layers": 3, + "enc_factor": 1.362875891969193, + "batch_size": 146, + "learning_rate": 5.3844605199721875e-05, + "drop_p": 0.19506356643369197, + "weight_decay": 0.007981074896648276, + "latent_dim": 57, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 815, + "n_layers": 2, + "enc_factor": 1.6774381747089042, + "batch_size": 131, + "learning_rate": 6.971864784140147e-05, + "drop_p": 0.24341889149862347, + "weight_decay": 0.0005143712642932365, + "latent_dim": 3, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 236, + "n_layers": 4, + "enc_factor": 2.9666089114381857, + "batch_size": 138, + "learning_rate": 0.013031621266672688, + "drop_p": 0.42370899811676555, + "weight_decay": 3.2203544082618995e-05, + "latent_dim": 48, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2058, + "n_layers": 3, + "enc_factor": 1.9798810796215531, + "batch_size": 228, + "learning_rate": 0.0076687178284143755, + "drop_p": 0.5075832909783595, + "weight_decay": 0.00018841748696609976, + "latent_dim": 25, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2660, + "n_layers": 4, + "enc_factor": 3.542990885913727, + "batch_size": 224, + "learning_rate": 0.03994643138748686, + "drop_p": 0.8281288884808854, + "weight_decay": 0.004405731627181012, + "latent_dim": 52, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 476, + "n_layers": 4, + "enc_factor": 1.1451722096843455, + "batch_size": 255, + "learning_rate": 0.0022905065843800343, + "drop_p": 0.5565403486473666, + "weight_decay": 0.030104257537547606, + "latent_dim": 3, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3295, + "n_layers": 3, + "enc_factor": 1.4940021668414722, + "batch_size": 238, + "learning_rate": 0.002530885554727104, + "drop_p": 0.3601526567488086, + "weight_decay": 0.002281829610161038, + "latent_dim": 21, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 176, + "n_layers": 2, + "enc_factor": 1.4251489204829042, + "batch_size": 199, + "learning_rate": 0.042484873366086, + "drop_p": 0.34427693481614063, + "weight_decay": 0.009737871297564286, + "latent_dim": 54, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2017, + "n_layers": 3, + "enc_factor": 3.104957322542364, + "batch_size": 178, + "learning_rate": 0.0007468995176395769, + "drop_p": 0.26310844531584976, + "weight_decay": 0.01056132752409984, + "latent_dim": 19, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 169, + "n_layers": 3, + "enc_factor": 1.781590135328858, + "batch_size": 222, + "learning_rate": 0.08723145124157897, + "drop_p": 0.23544494068626176, + "weight_decay": 0.012369767667429987, + "latent_dim": 35, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 4013, + "n_layers": 3, + "enc_factor": 1.9277939683353014, + "batch_size": 96, + "learning_rate": 1.3018702924209717e-05, + "drop_p": 0.7177972472326413, + "weight_decay": 0.0026294454818018556, + "latent_dim": 51, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2412, + "n_layers": 3, + "enc_factor": 3.0149172415087797, + "batch_size": 72, + "learning_rate": 9.958052167983653e-05, + "drop_p": 0.8592716701929051, + "weight_decay": 0.0001130028662327338, + "latent_dim": 15, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1778, + "n_layers": 3, + "enc_factor": 2.811186938506934, + "batch_size": 178, + "learning_rate": 0.002493857302711204, + "drop_p": 0.6199195540549111, + "weight_decay": 0.0027657231534807744, + "latent_dim": 48, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 216, + "n_layers": 2, + "enc_factor": 2.2968248129340783, + "batch_size": 54, + "learning_rate": 0.00161553723538576, + "drop_p": 0.5466518868593178, + "weight_decay": 0.003910928921244795, + "latent_dim": 51, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1315, + "n_layers": 3, + "enc_factor": 2.710300000208213, + "batch_size": 90, + "learning_rate": 0.0008849538664702332, + "drop_p": 0.8635766770877129, + "weight_decay": 0.015490611217358372, + "latent_dim": 31, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 463, + "n_layers": 3, + "enc_factor": 2.597301909551641, + "batch_size": 214, + "learning_rate": 0.0021151335049468503, + "drop_p": 0.3727575002921515, + "weight_decay": 1.3423234372142999e-05, + "latent_dim": 5, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 202, + "n_layers": 3, + "enc_factor": 2.9845289307273593, + "batch_size": 147, + "learning_rate": 0.0027569704841146642, + "drop_p": 0.10450152264149724, + "weight_decay": 0.0014478744062995555, + "latent_dim": 43, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2924, + "n_layers": 3, + "enc_factor": 3.335678422970373, + "batch_size": 158, + "learning_rate": 0.008564600747729047, + "drop_p": 0.24199296954715688, + "weight_decay": 4.3792720909589325e-05, + "latent_dim": 54, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3767, + "n_layers": 2, + "enc_factor": 3.315685739736053, + "batch_size": 252, + "learning_rate": 1.6993943662493045e-05, + "drop_p": 0.3474978878031825, + "weight_decay": 1.7541316835827892e-05, + "latent_dim": 46, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3146, + "n_layers": 4, + "enc_factor": 1.6922074366681803, + "batch_size": 107, + "learning_rate": 6.163894534250504e-05, + "drop_p": 0.21761231881712137, + "weight_decay": 0.002525775100305844, + "latent_dim": 3, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 137, + "n_layers": 4, + "enc_factor": 1.0700692953624125, + "batch_size": 139, + "learning_rate": 0.0018916780871981245, + "drop_p": 0.39083779421168563, + "weight_decay": 0.05834406730547362, + "latent_dim": 46, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1412, + "n_layers": 3, + "enc_factor": 2.7249548891967845, + "batch_size": 56, + "learning_rate": 0.0010388871423269133, + "drop_p": 0.7967697069149768, + "weight_decay": 0.03984474282759933, + "latent_dim": 31, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1105, + "n_layers": 2, + "enc_factor": 1.654040134575296, + "batch_size": 202, + "learning_rate": 0.002657918854169515, + "drop_p": 0.13952519938201938, + "weight_decay": 0.027801568331453152, + "latent_dim": 19, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 256, + "n_layers": 3, + "enc_factor": 3.489077839509614, + "batch_size": 208, + "learning_rate": 0.0005327282016325221, + "drop_p": 0.15502276915303068, + "weight_decay": 0.0004220131876716859, + "latent_dim": 13, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 860, + "n_layers": 3, + "enc_factor": 3.486013433399285, + "batch_size": 54, + "learning_rate": 1.016793507914453e-05, + "drop_p": 0.5969255429312488, + "weight_decay": 0.00042871268752967657, + "latent_dim": 12, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 313, + "n_layers": 4, + "enc_factor": 3.443947136844, + "batch_size": 145, + "learning_rate": 0.0004017470544620025, + "drop_p": 0.24341426041242395, + "weight_decay": 3.202179156971165e-05, + "latent_dim": 51, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 153, + "n_layers": 3, + "enc_factor": 2.0334224267009096, + "batch_size": 106, + "learning_rate": 0.008778659306680456, + "drop_p": 0.48729140354305606, + "weight_decay": 0.006005543531152502, + "latent_dim": 62, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3529, + "n_layers": 3, + "enc_factor": 2.4452868355555384, + "batch_size": 220, + "learning_rate": 0.0003832921370105254, + "drop_p": 0.2796253947882838, + "weight_decay": 1.5826152741090118e-05, + "latent_dim": 59, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3843, + "n_layers": 3, + "enc_factor": 2.1814315050151682, + "batch_size": 111, + "learning_rate": 0.01756095138970487, + "drop_p": 0.47082577886088106, + "weight_decay": 9.250475744530481e-05, + "latent_dim": 37, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2308, + "n_layers": 4, + "enc_factor": 2.7971677477794055, + "batch_size": 123, + "learning_rate": 0.0020160437424692965, + "drop_p": 0.043845344030369764, + "weight_decay": 0.0003339740947890777, + "latent_dim": 32, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 139, + "n_layers": 3, + "enc_factor": 2.4175388014809807, + "batch_size": 92, + "learning_rate": 0.0017119712322321548, + "drop_p": 0.09743533012161328, + "weight_decay": 5.322294215299974e-05, + "latent_dim": 51, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 486, + "n_layers": 3, + "enc_factor": 2.232319894914599, + "batch_size": 57, + "learning_rate": 2.984398163751966e-05, + "drop_p": 0.6227707652871984, + "weight_decay": 0.01183487534166925, + "latent_dim": 63, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 152, + "n_layers": 3, + "enc_factor": 2.9158338571398037, + "batch_size": 108, + "learning_rate": 0.000895816681015961, + "drop_p": 0.04251087633163377, + "weight_decay": 4.637281683036154e-05, + "latent_dim": 58, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3036, + "n_layers": 3, + "enc_factor": 2.32662102967546, + "batch_size": 79, + "learning_rate": 0.038088014755617294, + "drop_p": 0.456356624837416, + "weight_decay": 0.07953431977352278, + "latent_dim": 58, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 202, + "n_layers": 3, + "enc_factor": 3.8986218876446848, + "batch_size": 106, + "learning_rate": 0.0010171238562550298, + "drop_p": 0.05370834611621093, + "weight_decay": 1.5649189479764776e-05, + "latent_dim": 36, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 251, + "n_layers": 2, + "enc_factor": 3.021071388577269, + "batch_size": 165, + "learning_rate": 4.633422663220483e-05, + "drop_p": 0.128949160371417, + "weight_decay": 0.030183214139291314, + "latent_dim": 18, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 188, + "n_layers": 4, + "enc_factor": 2.472183852501533, + "batch_size": 208, + "learning_rate": 6.768025280865425e-05, + "drop_p": 0.04666787237132565, + "weight_decay": 0.05654205103495859, + "latent_dim": 52, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3646, + "n_layers": 3, + "enc_factor": 1.7896176727605857, + "batch_size": 61, + "learning_rate": 0.0009030738638363735, + "drop_p": 0.5606562189632055, + "weight_decay": 1.662134320221818e-05, + "latent_dim": 8, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3962, + "n_layers": 2, + "enc_factor": 2.5263080403611773, + "batch_size": 206, + "learning_rate": 0.0002348819759568408, + "drop_p": 0.6066692992855354, + "weight_decay": 0.00406692046805363, + "latent_dim": 16, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 138, + "n_layers": 3, + "enc_factor": 1.5619670354402801, + "batch_size": 225, + "learning_rate": 0.0007610691066710155, + "drop_p": 0.16814090409627536, + "weight_decay": 0.003976776575104322, + "latent_dim": 47, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 405, + "n_layers": 3, + "enc_factor": 3.132541708099063, + "batch_size": 153, + "learning_rate": 0.0002880240970467584, + "drop_p": 0.5141576182719765, + "weight_decay": 1.1794577984304836e-05, + "latent_dim": 10, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 197, + "n_layers": 2, + "enc_factor": 3.0580580111557665, + "batch_size": 173, + "learning_rate": 0.03846361120546517, + "drop_p": 0.6688187656435424, + "weight_decay": 0.0038204149071240897, + "latent_dim": 20, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 262, + "n_layers": 3, + "enc_factor": 2.70383405423072, + "batch_size": 100, + "learning_rate": 0.01278144863337572, + "drop_p": 0.16913609602830884, + "weight_decay": 1.6523718685533558e-05, + "latent_dim": 13, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 320, + "n_layers": 3, + "enc_factor": 1.6686120106067122, + "batch_size": 49, + "learning_rate": 4.123691661792349e-05, + "drop_p": 0.10170154166791162, + "weight_decay": 0.00014786346054374355, + "latent_dim": 48, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 177, + "n_layers": 3, + "enc_factor": 3.7622589884261446, + "batch_size": 192, + "learning_rate": 8.729568949648417e-05, + "drop_p": 0.7126270645574659, + "weight_decay": 0.0019636481597057544, + "latent_dim": 18, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 176, + "n_layers": 3, + "enc_factor": 1.170460188916953, + "batch_size": 178, + "learning_rate": 8.319248181486887e-05, + "drop_p": 0.5971396569619574, + "weight_decay": 0.0030287291354821654, + "latent_dim": 16, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 4044, + "n_layers": 3, + "enc_factor": 2.6967760038752293, + "batch_size": 110, + "learning_rate": 0.00014502692170179416, + "drop_p": 0.528426186093212, + "weight_decay": 0.08816112498589115, + "latent_dim": 49, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 218, + "n_layers": 4, + "enc_factor": 1.7942087668258704, + "batch_size": 88, + "learning_rate": 0.003054917790474075, + "drop_p": 0.004632931984798305, + "weight_decay": 0.00020161558372320143, + "latent_dim": 48, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3828, + "n_layers": 4, + "enc_factor": 3.6754764888633917, + "batch_size": 57, + "learning_rate": 0.039130561895581256, + "drop_p": 0.516735778665699, + "weight_decay": 0.014861609917595026, + "latent_dim": 25, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 962, + "n_layers": 2, + "enc_factor": 2.7847585930974676, + "batch_size": 98, + "learning_rate": 0.00012218620558268058, + "drop_p": 0.20826827967062417, + "weight_decay": 1.5681505315081402e-05, + "latent_dim": 5, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 244, + "n_layers": 2, + "enc_factor": 1.4382207874226673, + "batch_size": 36, + "learning_rate": 0.00018596962797010153, + "drop_p": 0.1016751032109643, + "weight_decay": 0.004683100558634616, + "latent_dim": 42, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1718, + "n_layers": 2, + "enc_factor": 1.565699018057971, + "batch_size": 155, + "learning_rate": 0.08224672220567777, + "drop_p": 0.8463865933745455, + "weight_decay": 1.7386046620587845e-05, + "latent_dim": 57, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 678, + "n_layers": 2, + "enc_factor": 2.1884357116036224, + "batch_size": 109, + "learning_rate": 0.0004171349217009964, + "drop_p": 0.7064183852977437, + "weight_decay": 0.07153310072144912, + "latent_dim": 42, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 190, + "n_layers": 3, + "enc_factor": 2.8802087707986423, + "batch_size": 151, + "learning_rate": 0.011670300704959634, + "drop_p": 0.36699219069484956, + "weight_decay": 0.00038709883460904285, + "latent_dim": 58, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2062, + "n_layers": 2, + "enc_factor": 2.5996360705406385, + "batch_size": 161, + "learning_rate": 0.0001639477195949418, + "drop_p": 0.8897084341134871, + "weight_decay": 0.04927978403376172, + "latent_dim": 5, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 330, + "n_layers": 2, + "enc_factor": 1.6176119216217644, + "batch_size": 88, + "learning_rate": 0.0023609220365937407, + "drop_p": 0.2106233594331184, + "weight_decay": 0.0006699334325820497, + "latent_dim": 57, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2144, + "n_layers": 2, + "enc_factor": 3.260397691024896, + "batch_size": 55, + "learning_rate": 0.00014971363767805155, + "drop_p": 0.02496552220007117, + "weight_decay": 2.8739580128895115e-05, + "latent_dim": 37, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3320, + "n_layers": 2, + "enc_factor": 3.6963220182005716, + "batch_size": 204, + "learning_rate": 0.00019055119811235187, + "drop_p": 0.34032602307957577, + "weight_decay": 0.034884248962137765, + "latent_dim": 40, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1375, + "n_layers": 3, + "enc_factor": 1.5736495707739322, + "batch_size": 63, + "learning_rate": 0.0002787179130114135, + "drop_p": 0.25796581521879414, + "weight_decay": 0.004703454765597469, + "latent_dim": 62, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 190, + "n_layers": 3, + "enc_factor": 1.7827617448939048, + "batch_size": 217, + "learning_rate": 0.005498508070152997, + "drop_p": 0.24763504388827554, + "weight_decay": 1.0404227579508307e-05, + "latent_dim": 13, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2351, + "n_layers": 4, + "enc_factor": 3.692211786189139, + "batch_size": 222, + "learning_rate": 0.0013331290372779337, + "drop_p": 0.2014112819842609, + "weight_decay": 9.101768695992732e-05, + "latent_dim": 4, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 359, + "n_layers": 3, + "enc_factor": 3.586916559027701, + "batch_size": 171, + "learning_rate": 0.0021570871432144436, + "drop_p": 0.5471428257335015, + "weight_decay": 0.003236196054976735, + "latent_dim": 34, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 189, + "n_layers": 3, + "enc_factor": 1.7978047941695263, + "batch_size": 223, + "learning_rate": 0.0004153185201577821, + "drop_p": 0.17701186967076168, + "weight_decay": 4.958356389867715e-05, + "latent_dim": 23, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3137, + "n_layers": 4, + "enc_factor": 1.9347087309125062, + "batch_size": 36, + "learning_rate": 0.040849621689031564, + "drop_p": 0.11625354905427536, + "weight_decay": 0.00017056112579397987, + "latent_dim": 48, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2559, + "n_layers": 3, + "enc_factor": 2.567236740284267, + "batch_size": 246, + "learning_rate": 0.04283260379527364, + "drop_p": 0.8929090808549514, + "weight_decay": 0.07804209923682506, + "latent_dim": 61, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + }, + "schc": { + "downstream": [ + { + "k_filter": 2524, + "n_layers": 2, + "enc_factor": 2.625709032253737, + "batch_size": 130, + "learning_rate": 0.0001753364330569271, + "drop_p": 0.050336520367739127, + "weight_decay": 0.06978554774173652, + "latent_dim": 43, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1353, + "n_layers": 3, + "enc_factor": 3.137599407527918, + "batch_size": 157, + "learning_rate": 7.561656212295817e-05, + "drop_p": 0.2880394606732049, + "weight_decay": 1.9820631810890047e-05, + "latent_dim": 62, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3226, + "n_layers": 2, + "enc_factor": 3.9249654763328783, + "batch_size": 106, + "learning_rate": 5.254944683910484e-05, + "drop_p": 0.3056777733947455, + "weight_decay": 0.0005367655951054707, + "latent_dim": 32, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 198, + "n_layers": 2, + "enc_factor": 1.3565584486890354, + "batch_size": 217, + "learning_rate": 0.011031872802333495, + "drop_p": 0.5475443427223023, + "weight_decay": 0.09434309499655999, + "latent_dim": 25, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3462, + "n_layers": 3, + "enc_factor": 1.3341091091404311, + "batch_size": 196, + "learning_rate": 1.1462332169313485e-05, + "drop_p": 0.7745685045591244, + "weight_decay": 1.7277106094586533e-05, + "latent_dim": 45, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3816, + "n_layers": 3, + "enc_factor": 2.2193206369525895, + "batch_size": 213, + "learning_rate": 0.0008590360321157138, + "drop_p": 0.3726567586561525, + "weight_decay": 0.0002695279291105882, + "latent_dim": 60, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3899, + "n_layers": 2, + "enc_factor": 1.7723957052368555, + "batch_size": 181, + "learning_rate": 0.0014786546011028127, + "drop_p": 0.01378516456414739, + "weight_decay": 0.09378495440051726, + "latent_dim": 59, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1016, + "n_layers": 3, + "enc_factor": 2.3378314526781296, + "batch_size": 253, + "learning_rate": 4.7007927415624385e-05, + "drop_p": 0.5900272105419117, + "weight_decay": 0.005850066666413092, + "latent_dim": 32, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3472, + "n_layers": 3, + "enc_factor": 3.737062717043288, + "batch_size": 81, + "learning_rate": 0.00013836725089483296, + "drop_p": 0.08731658459891746, + "weight_decay": 0.06462586597898555, + "latent_dim": 58, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3093, + "n_layers": 3, + "enc_factor": 2.470103453465393, + "batch_size": 90, + "learning_rate": 0.00037191365981411223, + "drop_p": 0.3034567305203645, + "weight_decay": 0.0011663629880233272, + "latent_dim": 54, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 215, + "n_layers": 2, + "enc_factor": 1.4947197646152537, + "batch_size": 160, + "learning_rate": 0.007565736211417187, + "drop_p": 0.2423169242511966, + "weight_decay": 0.004371147290824538, + "latent_dim": 59, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2154, + "n_layers": 4, + "enc_factor": 1.0342953479070007, + "batch_size": 174, + "learning_rate": 0.030781505975723943, + "drop_p": 0.2150355549534207, + "weight_decay": 0.0018095370429835065, + "latent_dim": 5, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3198, + "n_layers": 3, + "enc_factor": 1.1404662268632106, + "batch_size": 169, + "learning_rate": 0.0166265436020086, + "drop_p": 0.5297462941903748, + "weight_decay": 0.0003433203630449276, + "latent_dim": 35, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 169, + "n_layers": 3, + "enc_factor": 1.812555873319283, + "batch_size": 53, + "learning_rate": 0.022033582214618493, + "drop_p": 0.45377516754497005, + "weight_decay": 0.051554893700300836, + "latent_dim": 57, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 128, + "n_layers": 4, + "enc_factor": 2.5031476864349402, + "batch_size": 120, + "learning_rate": 0.005420473161486963, + "drop_p": 0.6067353463859892, + "weight_decay": 0.004983507555392378, + "latent_dim": 38, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3155, + "n_layers": 3, + "enc_factor": 1.2109366614655994, + "batch_size": 214, + "learning_rate": 0.0006349825019954114, + "drop_p": 0.6006722879748523, + "weight_decay": 0.0005808541174088302, + "latent_dim": 39, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 202, + "n_layers": 4, + "enc_factor": 1.243428008690628, + "batch_size": 172, + "learning_rate": 0.0019856909376547585, + "drop_p": 0.25923778419710714, + "weight_decay": 0.00010195998522667987, + "latent_dim": 35, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1546, + "n_layers": 2, + "enc_factor": 3.2831436645706833, + "batch_size": 58, + "learning_rate": 0.0011058013945115398, + "drop_p": 0.8163947444784608, + "weight_decay": 6.867278438603563e-05, + "latent_dim": 29, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 208, + "n_layers": 4, + "enc_factor": 3.1367138004847828, + "batch_size": 227, + "learning_rate": 0.0030254895640778982, + "drop_p": 0.02139235335810913, + "weight_decay": 0.00028263470157918654, + "latent_dim": 50, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3858, + "n_layers": 3, + "enc_factor": 1.9904506905901238, + "batch_size": 160, + "learning_rate": 1.4343727963077603e-05, + "drop_p": 0.0015823281983457728, + "weight_decay": 2.8983118541820593e-05, + "latent_dim": 5, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 291, + "n_layers": 3, + "enc_factor": 2.3387082726612705, + "batch_size": 150, + "learning_rate": 0.0038601364867895103, + "drop_p": 0.06416831986641877, + "weight_decay": 0.060944681744633106, + "latent_dim": 57, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 195, + "n_layers": 2, + "enc_factor": 2.6624724956702175, + "batch_size": 62, + "learning_rate": 7.73217623559534e-05, + "drop_p": 0.06987542607081976, + "weight_decay": 0.0001255229847311243, + "latent_dim": 8, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2312, + "n_layers": 3, + "enc_factor": 2.0909761627939814, + "batch_size": 224, + "learning_rate": 4.2036572175423444e-05, + "drop_p": 0.29428579336874905, + "weight_decay": 2.0829125387176313e-05, + "latent_dim": 4, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 912, + "n_layers": 4, + "enc_factor": 2.5363678414273503, + "batch_size": 67, + "learning_rate": 0.001447979707435187, + "drop_p": 0.7255567389805992, + "weight_decay": 0.00034647829855241873, + "latent_dim": 45, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 134, + "n_layers": 2, + "enc_factor": 1.6639432436564778, + "batch_size": 167, + "learning_rate": 0.001188516765309441, + "drop_p": 0.1658003057963716, + "weight_decay": 4.7365914359260187e-05, + "latent_dim": 25, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 329, + "n_layers": 2, + "enc_factor": 1.9908829949949587, + "batch_size": 42, + "learning_rate": 2.3101096908234998e-05, + "drop_p": 0.735048035165442, + "weight_decay": 0.05902063902877476, + "latent_dim": 58, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 218, + "n_layers": 2, + "enc_factor": 1.837434675740305, + "batch_size": 243, + "learning_rate": 0.0008469148994714997, + "drop_p": 0.7355451255035098, + "weight_decay": 0.00033908426255931936, + "latent_dim": 29, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 233, + "n_layers": 3, + "enc_factor": 1.1785439669864002, + "batch_size": 219, + "learning_rate": 0.004571663898024213, + "drop_p": 0.31976419656291116, + "weight_decay": 0.0061040666294068634, + "latent_dim": 51, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2218, + "n_layers": 3, + "enc_factor": 1.100278604823067, + "batch_size": 136, + "learning_rate": 9.06150430321639e-05, + "drop_p": 0.18712308750187742, + "weight_decay": 0.0001240221493263833, + "latent_dim": 6, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3078, + "n_layers": 2, + "enc_factor": 2.960569983709414, + "batch_size": 111, + "learning_rate": 0.0019509540633106271, + "drop_p": 0.6898478221349892, + "weight_decay": 0.0011102932704498845, + "latent_dim": 33, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 149, + "n_layers": 3, + "enc_factor": 2.439062074006101, + "batch_size": 44, + "learning_rate": 0.00022970555416184036, + "drop_p": 0.4380636331307193, + "weight_decay": 0.0009133326188211674, + "latent_dim": 43, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 232, + "n_layers": 3, + "enc_factor": 2.0029121014097457, + "batch_size": 131, + "learning_rate": 0.008801772714376318, + "drop_p": 0.4594134577506882, + "weight_decay": 0.0037486145193080414, + "latent_dim": 39, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2856, + "n_layers": 3, + "enc_factor": 2.8521247349477354, + "batch_size": 66, + "learning_rate": 1.4586314540299035e-05, + "drop_p": 0.28867429555423657, + "weight_decay": 0.00017115787697564292, + "latent_dim": 17, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2150, + "n_layers": 2, + "enc_factor": 2.991800712613501, + "batch_size": 226, + "learning_rate": 0.0012395231091692483, + "drop_p": 0.7519345033242482, + "weight_decay": 1.5112565938616332e-05, + "latent_dim": 22, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 236, + "n_layers": 3, + "enc_factor": 3.632497721524585, + "batch_size": 59, + "learning_rate": 0.0022037829250655797, + "drop_p": 0.8011141662552824, + "weight_decay": 0.0004995599971557854, + "latent_dim": 21, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1974, + "n_layers": 4, + "enc_factor": 2.784522341605915, + "batch_size": 169, + "learning_rate": 0.0030553005331799762, + "drop_p": 0.013366939381542087, + "weight_decay": 0.006849834198630659, + "latent_dim": 40, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 218, + "n_layers": 4, + "enc_factor": 3.9711417163604414, + "batch_size": 194, + "learning_rate": 0.00035511200540228136, + "drop_p": 0.08677042967664038, + "weight_decay": 4.6115967964650967e-05, + "latent_dim": 58, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2395, + "n_layers": 3, + "enc_factor": 2.705299811671803, + "batch_size": 42, + "learning_rate": 0.00011499026114842028, + "drop_p": 0.7009507602714802, + "weight_decay": 9.087495703829529e-05, + "latent_dim": 11, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 253, + "n_layers": 2, + "enc_factor": 2.7643664654887963, + "batch_size": 194, + "learning_rate": 0.001194534503464727, + "drop_p": 0.0018124077430398122, + "weight_decay": 3.860065941145678e-05, + "latent_dim": 38, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 721, + "n_layers": 3, + "enc_factor": 2.775659528905894, + "batch_size": 254, + "learning_rate": 0.0042028303773644325, + "drop_p": 0.14320042193795846, + "weight_decay": 3.393152502429746e-05, + "latent_dim": 45, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 364, + "n_layers": 2, + "enc_factor": 3.935532751116341, + "batch_size": 77, + "learning_rate": 0.0014770566721118833, + "drop_p": 0.26020785877129954, + "weight_decay": 0.0007734017096692778, + "latent_dim": 41, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 219, + "n_layers": 2, + "enc_factor": 1.3758966659760752, + "batch_size": 111, + "learning_rate": 0.001332249108973862, + "drop_p": 0.023780342113149222, + "weight_decay": 6.987560592421014e-05, + "latent_dim": 23, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3757, + "n_layers": 3, + "enc_factor": 1.922488848691234, + "batch_size": 45, + "learning_rate": 0.0002829908933077088, + "drop_p": 0.8534828870503985, + "weight_decay": 0.0005103970224592022, + "latent_dim": 58, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2323, + "n_layers": 3, + "enc_factor": 1.3145257103406758, + "batch_size": 75, + "learning_rate": 0.001672530232318351, + "drop_p": 0.11526469018973429, + "weight_decay": 1.3955333524553064e-05, + "latent_dim": 51, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 262, + "n_layers": 3, + "enc_factor": 3.6325928843805237, + "batch_size": 79, + "learning_rate": 0.0009064093200944076, + "drop_p": 0.2903944752061544, + "weight_decay": 0.002702376786017287, + "latent_dim": 19, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 188, + "n_layers": 3, + "enc_factor": 2.2642892065086184, + "batch_size": 96, + "learning_rate": 0.000755395313502938, + "drop_p": 0.7374998313236543, + "weight_decay": 0.006624488840964055, + "latent_dim": 9, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2297, + "n_layers": 4, + "enc_factor": 2.083150219090698, + "batch_size": 48, + "learning_rate": 4.4260035776654486e-05, + "drop_p": 0.030641264084197907, + "weight_decay": 0.022089702791908493, + "latent_dim": 5, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 204, + "n_layers": 2, + "enc_factor": 3.0884337943172593, + "batch_size": 46, + "learning_rate": 0.00022128523816697756, + "drop_p": 0.20695657787662444, + "weight_decay": 4.198108165939101e-05, + "latent_dim": 21, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 307, + "n_layers": 4, + "enc_factor": 1.3480490292315184, + "batch_size": 61, + "learning_rate": 0.08271939586394746, + "drop_p": 0.30972447743631226, + "weight_decay": 5.719027553468883e-05, + "latent_dim": 23, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1993, + "n_layers": 2, + "enc_factor": 3.544261008106977, + "batch_size": 202, + "learning_rate": 0.021334586025793675, + "drop_p": 0.3660634479912285, + "weight_decay": 0.005465179662257059, + "latent_dim": 20, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 181, + "n_layers": 3, + "enc_factor": 2.816300355380179, + "batch_size": 85, + "learning_rate": 0.01976736576818572, + "drop_p": 0.2922195135420467, + "weight_decay": 0.00025437856544848435, + "latent_dim": 9, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 218, + "n_layers": 2, + "enc_factor": 2.2432044311339165, + "batch_size": 48, + "learning_rate": 0.04065167967539348, + "drop_p": 0.49057041960311615, + "weight_decay": 1.0194348667088305e-05, + "latent_dim": 60, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 157, + "n_layers": 3, + "enc_factor": 3.2869331298136677, + "batch_size": 112, + "learning_rate": 0.003198764640185368, + "drop_p": 0.7610822892993775, + "weight_decay": 1.9151670215639104e-05, + "latent_dim": 42, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1100, + "n_layers": 2, + "enc_factor": 2.162802983348143, + "batch_size": 151, + "learning_rate": 4.299482915437596e-05, + "drop_p": 0.31422790153189206, + "weight_decay": 0.01234445384521892, + "latent_dim": 5, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 287, + "n_layers": 4, + "enc_factor": 1.9704270653400628, + "batch_size": 158, + "learning_rate": 0.0017058036947913272, + "drop_p": 0.4875248793044496, + "weight_decay": 3.7487293497769005e-05, + "latent_dim": 53, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 219, + "n_layers": 3, + "enc_factor": 1.6102745578156055, + "batch_size": 69, + "learning_rate": 0.0031352619409885127, + "drop_p": 0.1710180226435519, + "weight_decay": 0.009134533904590018, + "latent_dim": 59, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2159, + "n_layers": 3, + "enc_factor": 3.252543251251836, + "batch_size": 97, + "learning_rate": 0.0010203569707180656, + "drop_p": 0.4611626625077597, + "weight_decay": 0.018970470752454425, + "latent_dim": 8, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 246, + "n_layers": 4, + "enc_factor": 1.4345100940517015, + "batch_size": 44, + "learning_rate": 0.06476071990835312, + "drop_p": 0.7247523203363044, + "weight_decay": 3.6042017356148174e-05, + "latent_dim": 5, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1522, + "n_layers": 4, + "enc_factor": 1.97141525776668, + "batch_size": 90, + "learning_rate": 4.007540172243771e-05, + "drop_p": 0.00979550679964757, + "weight_decay": 0.003747122252057478, + "latent_dim": 27, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 204, + "n_layers": 3, + "enc_factor": 2.1509955181319564, + "batch_size": 139, + "learning_rate": 0.029414953867378, + "drop_p": 0.41677034548659186, + "weight_decay": 9.78678967557579e-05, + "latent_dim": 13, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 193, + "n_layers": 4, + "enc_factor": 1.816954305728351, + "batch_size": 184, + "learning_rate": 0.01484572107060809, + "drop_p": 0.5591838934649495, + "weight_decay": 0.0646203667304962, + "latent_dim": 2, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 455, + "n_layers": 2, + "enc_factor": 2.383312296878003, + "batch_size": 71, + "learning_rate": 0.03130831696268488, + "drop_p": 0.6410234224884331, + "weight_decay": 1.7185992728155216e-05, + "latent_dim": 9, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3648, + "n_layers": 3, + "enc_factor": 1.0864029158149044, + "batch_size": 34, + "learning_rate": 0.04503670574255961, + "drop_p": 0.6663219302818141, + "weight_decay": 0.0003842305107182392, + "latent_dim": 4, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2794, + "n_layers": 3, + "enc_factor": 1.8541047642443607, + "batch_size": 242, + "learning_rate": 0.00727409886861148, + "drop_p": 0.4197598968446377, + "weight_decay": 0.014020543254061314, + "latent_dim": 43, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 188, + "n_layers": 2, + "enc_factor": 3.7270315253275195, + "batch_size": 184, + "learning_rate": 0.05122620117691583, + "drop_p": 0.3205420823513109, + "weight_decay": 1.8011074334308736e-05, + "latent_dim": 38, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 183, + "n_layers": 3, + "enc_factor": 3.7368041669132084, + "batch_size": 221, + "learning_rate": 0.0005503875787865987, + "drop_p": 0.6315541293354404, + "weight_decay": 0.000150735108296611, + "latent_dim": 37, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 174, + "n_layers": 2, + "enc_factor": 3.771190602788565, + "batch_size": 124, + "learning_rate": 0.00018287295583891883, + "drop_p": 0.0887633194319175, + "weight_decay": 2.7193794345126777e-05, + "latent_dim": 64, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 214, + "n_layers": 3, + "enc_factor": 3.6551736004417372, + "batch_size": 119, + "learning_rate": 0.09836519889524196, + "drop_p": 0.10483054144923226, + "weight_decay": 0.0006142884828595527, + "latent_dim": 4, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3191, + "n_layers": 2, + "enc_factor": 3.128285225953071, + "batch_size": 116, + "learning_rate": 0.002001142111058627, + "drop_p": 0.7362868964298824, + "weight_decay": 0.00016162040329143417, + "latent_dim": 6, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 351, + "n_layers": 2, + "enc_factor": 2.9839308732302015, + "batch_size": 188, + "learning_rate": 0.021845414211066713, + "drop_p": 0.6330272672000675, + "weight_decay": 1.704342300642524e-05, + "latent_dim": 41, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 245, + "n_layers": 3, + "enc_factor": 3.4148714094193346, + "batch_size": 247, + "learning_rate": 0.00811346401845173, + "drop_p": 0.634889143883022, + "weight_decay": 0.019738074008536763, + "latent_dim": 20, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1350, + "n_layers": 3, + "enc_factor": 1.078380386969034, + "batch_size": 249, + "learning_rate": 0.0032122259078449732, + "drop_p": 0.17971208164013094, + "weight_decay": 0.03926719204690613, + "latent_dim": 62, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 209, + "n_layers": 3, + "enc_factor": 1.8202920575071757, + "batch_size": 55, + "learning_rate": 0.00048241757505490215, + "drop_p": 0.015130406120584762, + "weight_decay": 0.06472446311687353, + "latent_dim": 20, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3428, + "n_layers": 3, + "enc_factor": 3.166251930947888, + "batch_size": 138, + "learning_rate": 7.439885720122179e-05, + "drop_p": 0.04270866388695073, + "weight_decay": 0.011593204790814656, + "latent_dim": 12, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1733, + "n_layers": 4, + "enc_factor": 2.533187440704369, + "batch_size": 125, + "learning_rate": 1.0208768904837374e-05, + "drop_p": 0.29785028556490856, + "weight_decay": 0.011864972451212477, + "latent_dim": 21, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 151, + "n_layers": 2, + "enc_factor": 2.9456988191526756, + "batch_size": 248, + "learning_rate": 0.0035885586862854746, + "drop_p": 0.6735677957284708, + "weight_decay": 0.00020726697749919514, + "latent_dim": 35, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3816, + "n_layers": 3, + "enc_factor": 1.1046492022682382, + "batch_size": 81, + "learning_rate": 0.0018880703041546597, + "drop_p": 0.5183539678377741, + "weight_decay": 0.03135593512116335, + "latent_dim": 28, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 133, + "n_layers": 4, + "enc_factor": 1.5043639601955476, + "batch_size": 92, + "learning_rate": 0.0014986746291518807, + "drop_p": 0.07804218016129116, + "weight_decay": 0.00046424939372499447, + "latent_dim": 35, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 348, + "n_layers": 3, + "enc_factor": 1.9499256827812101, + "batch_size": 32, + "learning_rate": 0.00011512037925183187, + "drop_p": 0.690258748816556, + "weight_decay": 3.8422828214085345e-05, + "latent_dim": 55, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 211, + "n_layers": 4, + "enc_factor": 3.1773099224590107, + "batch_size": 227, + "learning_rate": 0.0012237749696167915, + "drop_p": 0.36581133182373204, + "weight_decay": 0.018925925631300206, + "latent_dim": 53, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + } + }, + "varix": { + "combined": { + "downstream": [ + { + "k_filter": 2845, + "n_layers": 3, + "enc_factor": 3.361073234459043, + "batch_size": 159, + "learning_rate": 0.0033023196273975707, + "drop_p": 0.2843712844782789, + "weight_decay": 1.0946336390920297e-05, + "beta": 0.1497123009757529, + "latent_dim": 58, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2677, + "n_layers": 4, + "enc_factor": 1.8759055790241845, + "batch_size": 170, + "learning_rate": 8.629522298260548e-05, + "drop_p": 0.37374096762324516, + "weight_decay": 0.00019577863808162882, + "beta": 0.002726360383223113, + "latent_dim": 15, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1584, + "n_layers": 3, + "enc_factor": 2.868828698170777, + "batch_size": 52, + "learning_rate": 0.0003654758769476195, + "drop_p": 0.006018606782762593, + "weight_decay": 0.05270917256533907, + "beta": 0.001932206694889414, + "latent_dim": 57, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2898, + "n_layers": 3, + "enc_factor": 1.6473174626929707, + "batch_size": 133, + "learning_rate": 0.06661492222861774, + "drop_p": 0.021212782617120587, + "weight_decay": 0.0007472035654211534, + "beta": 4.677569717198956, + "latent_dim": 10, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 652, + "n_layers": 3, + "enc_factor": 1.8504937074845333, + "batch_size": 76, + "learning_rate": 0.0009508924287903, + "drop_p": 0.78491458103283, + "weight_decay": 2.869095069093713e-05, + "beta": 0.02692626495207165, + "latent_dim": 57, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3042, + "n_layers": 3, + "enc_factor": 3.9566034876810927, + "batch_size": 127, + "learning_rate": 0.011097903127418058, + "drop_p": 0.32918933713559495, + "weight_decay": 0.000562033931751245, + "beta": 0.29492617558009093, + "latent_dim": 7, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 666, + "n_layers": 3, + "enc_factor": 1.5821686530541017, + "batch_size": 121, + "learning_rate": 0.00012712256183633393, + "drop_p": 0.1897773488474175, + "weight_decay": 8.747210225534157e-05, + "beta": 0.00315395845067962, + "latent_dim": 51, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3232, + "n_layers": 3, + "enc_factor": 3.9245810827410184, + "batch_size": 69, + "learning_rate": 0.04784542294393849, + "drop_p": 0.24687342240045262, + "weight_decay": 0.04222925684560585, + "beta": 4.038610209638292, + "latent_dim": 5, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 416, + "n_layers": 3, + "enc_factor": 2.012894744786183, + "batch_size": 118, + "learning_rate": 2.114476454854492e-05, + "drop_p": 0.273124617851032, + "weight_decay": 0.0006493959887116203, + "beta": 0.814146358077693, + "latent_dim": 21, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2021, + "n_layers": 3, + "enc_factor": 1.605868422113732, + "batch_size": 111, + "learning_rate": 0.0041054611632275985, + "drop_p": 0.011437427661083632, + "weight_decay": 0.006867984967922603, + "beta": 5.050777767357931, + "latent_dim": 16, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 541, + "n_layers": 3, + "enc_factor": 1.9804684340973684, + "batch_size": 77, + "learning_rate": 0.002717325723957953, + "drop_p": 0.35043148848100575, + "weight_decay": 0.0007864112552472494, + "beta": 0.006834620413671464, + "latent_dim": 28, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2364, + "n_layers": 2, + "enc_factor": 1.5361934723482507, + "batch_size": 122, + "learning_rate": 0.016495651229885448, + "drop_p": 0.7436434350994273, + "weight_decay": 0.0058003617069452675, + "beta": 7.280293783894691, + "latent_dim": 14, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 167, + "n_layers": 3, + "enc_factor": 1.897673199730901, + "batch_size": 33, + "learning_rate": 0.003892409946759678, + "drop_p": 0.3102688022311318, + "weight_decay": 0.0026862017895637022, + "beta": 0.0013105639782471901, + "latent_dim": 13, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 878, + "n_layers": 2, + "enc_factor": 3.3229069051228297, + "batch_size": 251, + "learning_rate": 0.0034999090621690362, + "drop_p": 0.7234811808820053, + "weight_decay": 0.00042203640687558827, + "beta": 0.05071001992794421, + "latent_dim": 25, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3691, + "n_layers": 3, + "enc_factor": 3.5437649600312513, + "batch_size": 125, + "learning_rate": 0.00022789737978763276, + "drop_p": 0.17655483059647017, + "weight_decay": 0.00021324962486955057, + "beta": 0.07790897599271697, + "latent_dim": 25, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2819, + "n_layers": 3, + "enc_factor": 3.5308905072483863, + "batch_size": 171, + "learning_rate": 3.644417421458126e-05, + "drop_p": 0.3883972272832959, + "weight_decay": 0.004127385877141071, + "beta": 0.023561857582572933, + "latent_dim": 55, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2367, + "n_layers": 3, + "enc_factor": 2.79341819642668, + "batch_size": 141, + "learning_rate": 3.7012110916304445e-05, + "drop_p": 0.5394731531542065, + "weight_decay": 0.00022937030450716632, + "beta": 0.002670548797709649, + "latent_dim": 35, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3010, + "n_layers": 4, + "enc_factor": 2.072585629365677, + "batch_size": 73, + "learning_rate": 0.09665840932167402, + "drop_p": 0.48701821145631746, + "weight_decay": 0.03840082733589405, + "beta": 0.3836483958404996, + "latent_dim": 11, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2214, + "n_layers": 2, + "enc_factor": 2.207968105659378, + "batch_size": 190, + "learning_rate": 1.5385865420639284e-05, + "drop_p": 0.6888239597222837, + "weight_decay": 0.005117001011281384, + "beta": 0.7970002177238305, + "latent_dim": 28, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 926, + "n_layers": 3, + "enc_factor": 1.254025438421061, + "batch_size": 220, + "learning_rate": 2.0632247655047428e-05, + "drop_p": 0.12469362811275375, + "weight_decay": 0.0003181266600791934, + "beta": 0.0021759549774962744, + "latent_dim": 19, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 268, + "n_layers": 3, + "enc_factor": 3.3410215034367736, + "batch_size": 138, + "learning_rate": 0.06805756191277586, + "drop_p": 0.1504994244212262, + "weight_decay": 0.0014686090635267, + "beta": 0.015114605728980327, + "latent_dim": 55, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1178, + "n_layers": 3, + "enc_factor": 2.1897821282114385, + "batch_size": 102, + "learning_rate": 3.1132578919474505e-05, + "drop_p": 0.3801605712212628, + "weight_decay": 0.000327631709732215, + "beta": 0.006363337085495307, + "latent_dim": 5, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 168, + "n_layers": 3, + "enc_factor": 3.5418043947081888, + "batch_size": 124, + "learning_rate": 0.005027878848999338, + "drop_p": 0.16483161999019488, + "weight_decay": 0.001767174122738828, + "beta": 0.0010794607596247173, + "latent_dim": 30, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 132, + "n_layers": 3, + "enc_factor": 1.1020054365907042, + "batch_size": 132, + "learning_rate": 6.412083848455526e-05, + "drop_p": 0.640377948818801, + "weight_decay": 0.05346814537482855, + "beta": 0.002715029698441037, + "latent_dim": 54, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3541, + "n_layers": 2, + "enc_factor": 1.3295857729443532, + "batch_size": 47, + "learning_rate": 1.7066725482796798e-05, + "drop_p": 0.33540901425052455, + "weight_decay": 0.00017407793439558794, + "beta": 6.966055668437451, + "latent_dim": 18, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2763, + "n_layers": 3, + "enc_factor": 3.823085364740491, + "batch_size": 205, + "learning_rate": 0.015642408088495898, + "drop_p": 0.31116309786548624, + "weight_decay": 7.7261124715482e-05, + "beta": 0.08372796249734019, + "latent_dim": 25, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2377, + "n_layers": 3, + "enc_factor": 2.121083343453126, + "batch_size": 42, + "learning_rate": 0.00021679641499574795, + "drop_p": 0.8703637454545227, + "weight_decay": 0.001950559768606771, + "beta": 0.0223097085547984, + "latent_dim": 56, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 237, + "n_layers": 3, + "enc_factor": 1.7063534738404793, + "batch_size": 125, + "learning_rate": 0.0038628583782487095, + "drop_p": 0.05018298462727333, + "weight_decay": 0.00012267868140613741, + "beta": 0.0017280246098143896, + "latent_dim": 32, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3371, + "n_layers": 3, + "enc_factor": 1.6758835695757057, + "batch_size": 246, + "learning_rate": 5.548597051500216e-05, + "drop_p": 0.7798380944292335, + "weight_decay": 0.0014286999706820582, + "beta": 0.0156537419245193, + "latent_dim": 22, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1675, + "n_layers": 2, + "enc_factor": 2.2342365294874407, + "batch_size": 142, + "learning_rate": 0.008725445628413351, + "drop_p": 0.3698602753473218, + "weight_decay": 6.631532319082461e-05, + "beta": 3.175318093664771, + "latent_dim": 11, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 718, + "n_layers": 3, + "enc_factor": 1.9777265078010173, + "batch_size": 182, + "learning_rate": 0.002190122698926713, + "drop_p": 0.23600920229783198, + "weight_decay": 0.09826424696929824, + "beta": 0.5839763374364625, + "latent_dim": 31, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 220, + "n_layers": 4, + "enc_factor": 1.7122654807764912, + "batch_size": 175, + "learning_rate": 0.013789779549849565, + "drop_p": 0.5541879389401917, + "weight_decay": 0.00047038119143363605, + "beta": 7.26726390945721, + "latent_dim": 19, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 263, + "n_layers": 3, + "enc_factor": 2.0620957297793114, + "batch_size": 60, + "learning_rate": 1.4736370658634068e-05, + "drop_p": 0.06820710052293998, + "weight_decay": 0.005334685302305579, + "beta": 0.07643195769491923, + "latent_dim": 54, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 253, + "n_layers": 3, + "enc_factor": 2.1561385204862042, + "batch_size": 72, + "learning_rate": 0.00015928640063422457, + "drop_p": 0.30387900171258153, + "weight_decay": 0.015077223094824722, + "beta": 0.9702818344776588, + "latent_dim": 50, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1641, + "n_layers": 2, + "enc_factor": 2.1121620092226276, + "batch_size": 162, + "learning_rate": 0.0006743436846755056, + "drop_p": 0.5101963268769578, + "weight_decay": 0.0017510568180968216, + "beta": 0.05275514874961877, + "latent_dim": 53, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1019, + "n_layers": 2, + "enc_factor": 1.57945356732058, + "batch_size": 184, + "learning_rate": 0.0028033475195397644, + "drop_p": 0.5409848273886875, + "weight_decay": 0.029853999557361677, + "beta": 0.0017939470164979624, + "latent_dim": 28, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2584, + "n_layers": 4, + "enc_factor": 2.9354169398799677, + "batch_size": 252, + "learning_rate": 0.007166030840078724, + "drop_p": 0.7633997558698504, + "weight_decay": 0.005941036225051553, + "beta": 2.03914468269275, + "latent_dim": 56, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2030, + "n_layers": 3, + "enc_factor": 2.5430232960234784, + "batch_size": 246, + "learning_rate": 6.732974438477655e-05, + "drop_p": 0.8612202530817332, + "weight_decay": 0.00011610844898821151, + "beta": 1.0018921905666311, + "latent_dim": 51, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3500, + "n_layers": 3, + "enc_factor": 2.8419289789600883, + "batch_size": 242, + "learning_rate": 4.8433728230997574e-05, + "drop_p": 0.032313684907862184, + "weight_decay": 0.0026726859262311236, + "beta": 5.577211668187884, + "latent_dim": 10, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1115, + "n_layers": 2, + "enc_factor": 3.5019305736490596, + "batch_size": 81, + "learning_rate": 0.00017201407335840042, + "drop_p": 0.045002377949862664, + "weight_decay": 0.00011698509901428449, + "beta": 0.0021830596991683562, + "latent_dim": 16, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 519, + "n_layers": 2, + "enc_factor": 3.714895904245828, + "batch_size": 129, + "learning_rate": 0.000701353739481735, + "drop_p": 0.07637394718518763, + "weight_decay": 0.0007010383959967213, + "beta": 0.00332643942283234, + "latent_dim": 43, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2024, + "n_layers": 3, + "enc_factor": 2.885141627431417, + "batch_size": 172, + "learning_rate": 3.9643668581230566e-05, + "drop_p": 0.20129738486609838, + "weight_decay": 0.0003592300915386863, + "beta": 0.17081920094763778, + "latent_dim": 4, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 193, + "n_layers": 3, + "enc_factor": 2.6507772456231793, + "batch_size": 43, + "learning_rate": 0.00016137414303692038, + "drop_p": 0.2429582065639396, + "weight_decay": 2.9400295355190002e-05, + "beta": 0.009510291184589846, + "latent_dim": 27, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3562, + "n_layers": 4, + "enc_factor": 3.074097043949723, + "batch_size": 39, + "learning_rate": 0.0026956928593097978, + "drop_p": 0.8503838768080891, + "weight_decay": 8.909874241230307e-05, + "beta": 3.2908491502394757, + "latent_dim": 62, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3379, + "n_layers": 3, + "enc_factor": 3.900745242076708, + "batch_size": 68, + "learning_rate": 0.00016737714057233976, + "drop_p": 0.17761784623760504, + "weight_decay": 0.0006014645414303889, + "beta": 0.004771918767523261, + "latent_dim": 46, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1604, + "n_layers": 3, + "enc_factor": 1.6786814604595115, + "batch_size": 46, + "learning_rate": 3.071054867407732e-05, + "drop_p": 0.550240014477441, + "weight_decay": 0.00512009572893153, + "beta": 0.09660957318053921, + "latent_dim": 29, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2529, + "n_layers": 2, + "enc_factor": 2.197688843265359, + "batch_size": 170, + "learning_rate": 0.03696601091204546, + "drop_p": 0.7474546937317559, + "weight_decay": 0.007940065278300474, + "beta": 1.64239797351535, + "latent_dim": 10, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3526, + "n_layers": 2, + "enc_factor": 2.6118696823733174, + "batch_size": 45, + "learning_rate": 0.0005040751819508502, + "drop_p": 0.3670793511782143, + "weight_decay": 0.02932133184253119, + "beta": 0.26558212658307706, + "latent_dim": 43, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3085, + "n_layers": 3, + "enc_factor": 2.676586687603884, + "batch_size": 64, + "learning_rate": 0.00011689675026990401, + "drop_p": 0.01739679998507594, + "weight_decay": 0.0002652529547933088, + "beta": 0.14924974949105138, + "latent_dim": 28, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1874, + "n_layers": 3, + "enc_factor": 3.7846336545276253, + "batch_size": 84, + "learning_rate": 0.007850014765751723, + "drop_p": 0.8859655780563053, + "weight_decay": 0.0096766965004649, + "beta": 0.3304492502985077, + "latent_dim": 22, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 1959, + "n_layers": 4, + "enc_factor": 2.5936466371828564, + "batch_size": 196, + "learning_rate": 0.015418273135236726, + "drop_p": 0.6404574139290315, + "weight_decay": 0.00015277722321418476, + "beta": 0.00917716350953192, + "latent_dim": 8, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 131, + "n_layers": 4, + "enc_factor": 3.8281312346021945, + "batch_size": 117, + "learning_rate": 0.0018757281455477372, + "drop_p": 0.12036625468651856, + "weight_decay": 0.007433297653164314, + "beta": 0.002467102780916379, + "latent_dim": 28, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1118, + "n_layers": 4, + "enc_factor": 3.7823864082743865, + "batch_size": 70, + "learning_rate": 0.07589839370471642, + "drop_p": 0.4067821189108743, + "weight_decay": 0.0879298278945011, + "beta": 0.001433339673962062, + "latent_dim": 10, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 140, + "n_layers": 2, + "enc_factor": 1.2597231216467453, + "batch_size": 76, + "learning_rate": 0.0004651243194055217, + "drop_p": 0.5889270864134387, + "weight_decay": 0.0006137364453512724, + "beta": 3.7857943281694753, + "latent_dim": 17, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 412, + "n_layers": 2, + "enc_factor": 3.40077851301161, + "batch_size": 35, + "learning_rate": 0.006539018217127923, + "drop_p": 0.17556479335175287, + "weight_decay": 5.4789014958933025e-05, + "beta": 4.493781215526585, + "latent_dim": 7, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1228, + "n_layers": 4, + "enc_factor": 1.4539222545131247, + "batch_size": 98, + "learning_rate": 0.000874200302015598, + "drop_p": 0.8494540151984368, + "weight_decay": 0.01592620588887653, + "beta": 1.941252180029001, + "latent_dim": 50, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3921, + "n_layers": 3, + "enc_factor": 2.2044375177500015, + "batch_size": 53, + "learning_rate": 0.002553565897508214, + "drop_p": 0.6764822205335154, + "weight_decay": 3.301737004370618e-05, + "beta": 0.05387217064499541, + "latent_dim": 20, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2278, + "n_layers": 2, + "enc_factor": 3.416235241157473, + "batch_size": 219, + "learning_rate": 0.0002609538117618291, + "drop_p": 0.48497149724002603, + "weight_decay": 0.07138046749704441, + "beta": 0.10845536928727328, + "latent_dim": 12, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2489, + "n_layers": 3, + "enc_factor": 2.7600893349221294, + "batch_size": 254, + "learning_rate": 9.85135065176685e-05, + "drop_p": 0.3764484059889988, + "weight_decay": 0.020746673897664172, + "beta": 0.0033905310093333917, + "latent_dim": 21, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 231, + "n_layers": 2, + "enc_factor": 2.0437696775959515, + "batch_size": 160, + "learning_rate": 0.000364935922850297, + "drop_p": 0.1200944960540805, + "weight_decay": 0.00429233509881275, + "beta": 0.0011281787346488074, + "latent_dim": 59, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 192, + "n_layers": 4, + "enc_factor": 2.0763707627059986, + "batch_size": 127, + "learning_rate": 0.00014924157910374748, + "drop_p": 0.05791022635230778, + "weight_decay": 0.00010217215965823415, + "beta": 0.5172106419526084, + "latent_dim": 52, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2950, + "n_layers": 3, + "enc_factor": 1.7865231824573704, + "batch_size": 108, + "learning_rate": 4.391248868956259e-05, + "drop_p": 0.22554370684533254, + "weight_decay": 0.011151184128550535, + "beta": 0.004722441174742101, + "latent_dim": 3, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 781, + "n_layers": 4, + "enc_factor": 2.517387945913989, + "batch_size": 243, + "learning_rate": 0.004898663093681653, + "drop_p": 0.042840537508819235, + "weight_decay": 0.004797596895851841, + "beta": 0.0012005244767731105, + "latent_dim": 35, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 148, + "n_layers": 4, + "enc_factor": 2.709863506860167, + "batch_size": 241, + "learning_rate": 0.00044867982737913206, + "drop_p": 0.18781634077951923, + "weight_decay": 0.019205678932490512, + "beta": 0.01271383175838624, + "latent_dim": 20, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2818, + "n_layers": 2, + "enc_factor": 1.1032225799790611, + "batch_size": 160, + "learning_rate": 1.1074922026292722e-05, + "drop_p": 0.1942215998961221, + "weight_decay": 0.007758021771925683, + "beta": 0.006347532346703138, + "latent_dim": 43, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1398, + "n_layers": 4, + "enc_factor": 2.824952300496307, + "batch_size": 167, + "learning_rate": 0.0016027779445550595, + "drop_p": 0.28883675995737496, + "weight_decay": 0.009811412240997217, + "beta": 1.104447133344757, + "latent_dim": 7, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 311, + "n_layers": 4, + "enc_factor": 1.4560805271575754, + "batch_size": 102, + "learning_rate": 4.192473842934557e-05, + "drop_p": 0.8209991384179048, + "weight_decay": 0.0040131550299914815, + "beta": 0.0167462012790491, + "latent_dim": 30, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3506, + "n_layers": 3, + "enc_factor": 3.055094806257788, + "batch_size": 116, + "learning_rate": 0.0004183431626287192, + "drop_p": 0.08059125171971866, + "weight_decay": 0.0006383571603516128, + "beta": 0.21953212078123738, + "latent_dim": 58, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 760, + "n_layers": 2, + "enc_factor": 1.8864596171737393, + "batch_size": 149, + "learning_rate": 0.011676599322200129, + "drop_p": 0.8813057060101073, + "weight_decay": 0.026592590420616912, + "beta": 3.5882884576473812, + "latent_dim": 15, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 179, + "n_layers": 2, + "enc_factor": 1.366784780716542, + "batch_size": 253, + "learning_rate": 0.002614788614564103, + "drop_p": 0.08967194463895149, + "weight_decay": 0.0009293379123179974, + "beta": 0.009621867436806519, + "latent_dim": 24, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 384, + "n_layers": 2, + "enc_factor": 2.804013009039549, + "batch_size": 45, + "learning_rate": 0.00015272787886118968, + "drop_p": 0.09977012715489865, + "weight_decay": 0.004433577897219041, + "beta": 0.008208207356004336, + "latent_dim": 53, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2662, + "n_layers": 3, + "enc_factor": 1.526666833061923, + "batch_size": 231, + "learning_rate": 0.0021411940629834747, + "drop_p": 0.6996060969472071, + "weight_decay": 0.0789184513365815, + "beta": 0.05710284665239911, + "latent_dim": 40, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 244, + "n_layers": 4, + "enc_factor": 1.7771241434781295, + "batch_size": 56, + "learning_rate": 0.0002200447701985038, + "drop_p": 0.04032623912671542, + "weight_decay": 0.0007504750020810526, + "beta": 0.002936170339078701, + "latent_dim": 46, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2946, + "n_layers": 3, + "enc_factor": 1.1673936486716403, + "batch_size": 98, + "learning_rate": 0.004281421516664142, + "drop_p": 0.4782965150208467, + "weight_decay": 0.004263960584930674, + "beta": 5.151609502485034, + "latent_dim": 33, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2051, + "n_layers": 3, + "enc_factor": 2.9883278891350793, + "batch_size": 105, + "learning_rate": 1.4637932121584487e-05, + "drop_p": 0.5199115665413317, + "weight_decay": 0.00011092464873028055, + "beta": 0.5108807531181129, + "latent_dim": 51, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3299, + "n_layers": 3, + "enc_factor": 1.774192851502598, + "batch_size": 56, + "learning_rate": 0.005170944296849464, + "drop_p": 0.7975189106082272, + "weight_decay": 0.008806288100100979, + "beta": 0.003993347880471535, + "latent_dim": 21, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2916, + "n_layers": 3, + "enc_factor": 1.671861051715779, + "batch_size": 62, + "learning_rate": 0.05411564899622095, + "drop_p": 0.6894579613058226, + "weight_decay": 0.00207426201904872, + "beta": 0.3655605636811238, + "latent_dim": 27, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2649, + "n_layers": 2, + "enc_factor": 3.4649523104860376, + "batch_size": 251, + "learning_rate": 0.004821795517058323, + "drop_p": 0.25773010583713835, + "weight_decay": 1.6694953359367453e-05, + "beta": 0.06321769554397673, + "latent_dim": 18, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 275, + "n_layers": 3, + "enc_factor": 1.1838767511264239, + "batch_size": 121, + "learning_rate": 0.08329324585995516, + "drop_p": 0.5802151164967692, + "weight_decay": 2.250100498538255e-05, + "beta": 0.004171626200890971, + "latent_dim": 29, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1783, + "n_layers": 3, + "enc_factor": 3.752484249483494, + "batch_size": 188, + "learning_rate": 0.0613951924059475, + "drop_p": 0.2025105443426429, + "weight_decay": 0.004288277412811301, + "beta": 0.020973034335902495, + "latent_dim": 54, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + }, + "tcga": { + "downstream": [ + { + "k_filter": 1394, + "n_layers": 2, + "enc_factor": 3.0496070239762147, + "batch_size": 219, + "learning_rate": 0.022805278717863812, + "drop_p": 0.19621402160268422, + "weight_decay": 0.002781290503373996, + "beta": 0.027217187928069608, + "latent_dim": 54, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3077, + "n_layers": 3, + "enc_factor": 1.502146273773246, + "batch_size": 185, + "learning_rate": 6.161738424946646e-05, + "drop_p": 0.0004968877567736452, + "weight_decay": 0.0013463859386996936, + "beta": 0.001985862394452443, + "latent_dim": 58, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1451, + "n_layers": 4, + "enc_factor": 3.219913453776961, + "batch_size": 135, + "learning_rate": 0.010749106023452524, + "drop_p": 0.8233623172497693, + "weight_decay": 1.5083570333819646e-05, + "beta": 0.00249058573020994, + "latent_dim": 5, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3014, + "n_layers": 3, + "enc_factor": 2.0412055363164807, + "batch_size": 84, + "learning_rate": 2.016243536055329e-05, + "drop_p": 0.12657756464011127, + "weight_decay": 0.016306684623021053, + "beta": 1.2973367123959307, + "latent_dim": 37, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1086, + "n_layers": 3, + "enc_factor": 2.3718578755742, + "batch_size": 59, + "learning_rate": 0.00016349246341899353, + "drop_p": 0.12536657935483286, + "weight_decay": 2.114993941672861e-05, + "beta": 1.4435957657046565, + "latent_dim": 51, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2608, + "n_layers": 4, + "enc_factor": 1.9348632398139685, + "batch_size": 223, + "learning_rate": 0.0005491775452797518, + "drop_p": 0.001181067760032728, + "weight_decay": 0.009585097488424978, + "beta": 0.0021078813977428584, + "latent_dim": 52, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3935, + "n_layers": 4, + "enc_factor": 1.9596688679703411, + "batch_size": 249, + "learning_rate": 0.005758082401015622, + "drop_p": 0.03407399276631036, + "weight_decay": 4.483707651560749e-05, + "beta": 0.0032324772055221415, + "latent_dim": 37, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3123, + "n_layers": 3, + "enc_factor": 2.6928246401673954, + "batch_size": 214, + "learning_rate": 0.0792105873235122, + "drop_p": 0.12889810487121223, + "weight_decay": 0.0005740462712563143, + "beta": 0.38176884027140695, + "latent_dim": 9, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3046, + "n_layers": 4, + "enc_factor": 1.9580626530082206, + "batch_size": 84, + "learning_rate": 0.0012406320955303679, + "drop_p": 0.010454004715482147, + "weight_decay": 3.290466626874353e-05, + "beta": 3.905103240937441, + "latent_dim": 17, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3688, + "n_layers": 2, + "enc_factor": 3.301035036631079, + "batch_size": 195, + "learning_rate": 6.291970448994309e-05, + "drop_p": 0.5128792343373679, + "weight_decay": 0.010676922626761268, + "beta": 4.7724462317684555, + "latent_dim": 44, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 374, + "n_layers": 2, + "enc_factor": 1.5991352506589738, + "batch_size": 102, + "learning_rate": 0.02118575207230584, + "drop_p": 0.6445729514175086, + "weight_decay": 0.009174019092789996, + "beta": 0.015342501454455102, + "latent_dim": 51, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1610, + "n_layers": 4, + "enc_factor": 2.238768623100452, + "batch_size": 216, + "learning_rate": 0.004304311909977174, + "drop_p": 0.20735032114135418, + "weight_decay": 0.03529211838179183, + "beta": 0.3117250543342117, + "latent_dim": 44, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 243, + "n_layers": 3, + "enc_factor": 3.0097846896048357, + "batch_size": 73, + "learning_rate": 0.00026010360294215077, + "drop_p": 0.1268170707661979, + "weight_decay": 5.637577370242227e-05, + "beta": 0.0010241054899608176, + "latent_dim": 25, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 212, + "n_layers": 2, + "enc_factor": 3.6150356832982915, + "batch_size": 204, + "learning_rate": 0.013645102332647431, + "drop_p": 0.041033281403706066, + "weight_decay": 0.00364502697463293, + "beta": 1.0884253787344278, + "latent_dim": 58, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1169, + "n_layers": 3, + "enc_factor": 2.8580118027154517, + "batch_size": 67, + "learning_rate": 1.1885940042272594e-05, + "drop_p": 0.8339120926240182, + "weight_decay": 0.014758787575959973, + "beta": 0.0013264356532805344, + "latent_dim": 4, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3151, + "n_layers": 3, + "enc_factor": 2.604199759631029, + "batch_size": 206, + "learning_rate": 0.0008444043786565143, + "drop_p": 0.11637214483894683, + "weight_decay": 0.00014396632050053574, + "beta": 2.085090398936215, + "latent_dim": 35, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 566, + "n_layers": 2, + "enc_factor": 1.8304840383642915, + "batch_size": 60, + "learning_rate": 0.00017997330336436067, + "drop_p": 0.4002623979796094, + "weight_decay": 0.003945358130079226, + "beta": 0.05061931626186936, + "latent_dim": 44, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1576, + "n_layers": 2, + "enc_factor": 2.2540792326116765, + "batch_size": 228, + "learning_rate": 0.008771746604486897, + "drop_p": 0.7958114158208205, + "weight_decay": 0.011084942019740312, + "beta": 0.06438409870678617, + "latent_dim": 53, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 319, + "n_layers": 3, + "enc_factor": 2.838894141538268, + "batch_size": 45, + "learning_rate": 0.0005423190847763947, + "drop_p": 0.43836360610683883, + "weight_decay": 0.03238829935831466, + "beta": 0.03489661336413925, + "latent_dim": 3, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 493, + "n_layers": 3, + "enc_factor": 3.687644363333836, + "batch_size": 127, + "learning_rate": 0.04142813292884673, + "drop_p": 0.14847558006141387, + "weight_decay": 0.007775027779957993, + "beta": 0.8832224835909891, + "latent_dim": 38, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 174, + "n_layers": 3, + "enc_factor": 2.82629564672574, + "batch_size": 113, + "learning_rate": 0.0009831264180131657, + "drop_p": 0.1704057369134737, + "weight_decay": 0.07744988167365834, + "beta": 2.0836269344933522, + "latent_dim": 17, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 396, + "n_layers": 3, + "enc_factor": 3.809036577379419, + "batch_size": 169, + "learning_rate": 0.00011054484140256607, + "drop_p": 0.14852457280507797, + "weight_decay": 2.4198101765741895e-05, + "beta": 0.20485918533962316, + "latent_dim": 37, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 135, + "n_layers": 2, + "enc_factor": 3.2404040834294103, + "batch_size": 214, + "learning_rate": 0.008960900402483719, + "drop_p": 0.3859772337478549, + "weight_decay": 0.00010011153865052817, + "beta": 0.04768633235717646, + "latent_dim": 21, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 781, + "n_layers": 3, + "enc_factor": 3.3951217006231893, + "batch_size": 37, + "learning_rate": 0.0021790448568254975, + "drop_p": 0.5766775246664475, + "weight_decay": 0.0003891060391885883, + "beta": 5.664243392987719, + "latent_dim": 17, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1449, + "n_layers": 4, + "enc_factor": 2.2401936126349886, + "batch_size": 230, + "learning_rate": 2.3604394908688805e-05, + "drop_p": 0.3787967784431875, + "weight_decay": 0.00036377787452500913, + "beta": 0.22379053734525928, + "latent_dim": 50, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 992, + "n_layers": 3, + "enc_factor": 3.0330158386671524, + "batch_size": 253, + "learning_rate": 4.186347983156155e-05, + "drop_p": 0.544278134465911, + "weight_decay": 5.634495225599797e-05, + "beta": 0.021852078538967253, + "latent_dim": 5, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2844, + "n_layers": 2, + "enc_factor": 3.8523382339665213, + "batch_size": 144, + "learning_rate": 0.0022643058778665077, + "drop_p": 0.2264257954327624, + "weight_decay": 0.006185355264292936, + "beta": 7.393645329621664, + "latent_dim": 35, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 484, + "n_layers": 4, + "enc_factor": 3.7364082277419595, + "batch_size": 75, + "learning_rate": 0.000887270695578636, + "drop_p": 0.124995410775426, + "weight_decay": 0.004212257720326478, + "beta": 5.565601944372625, + "latent_dim": 18, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 202, + "n_layers": 4, + "enc_factor": 3.6543849500591943, + "batch_size": 56, + "learning_rate": 0.015272655884094858, + "drop_p": 0.02294946820595407, + "weight_decay": 0.012196499760461957, + "beta": 2.0838196472965347, + "latent_dim": 49, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 689, + "n_layers": 3, + "enc_factor": 2.8039316527260265, + "batch_size": 169, + "learning_rate": 0.001515288930741621, + "drop_p": 0.354808635597913, + "weight_decay": 1.0458101678560998e-05, + "beta": 0.002213290303905585, + "latent_dim": 30, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 319, + "n_layers": 3, + "enc_factor": 1.1625957050767377, + "batch_size": 252, + "learning_rate": 0.003978782904498988, + "drop_p": 0.45559367435221093, + "weight_decay": 4.62722675814489e-05, + "beta": 0.0011447165026768529, + "latent_dim": 5, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 134, + "n_layers": 4, + "enc_factor": 1.219801101635927, + "batch_size": 57, + "learning_rate": 0.010794984282144727, + "drop_p": 0.23260607277201048, + "weight_decay": 0.024330917110605223, + "beta": 2.0271778297858325, + "latent_dim": 37, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3590, + "n_layers": 3, + "enc_factor": 2.2652304294399386, + "batch_size": 126, + "learning_rate": 1.2996878146198463e-05, + "drop_p": 0.6029937555232451, + "weight_decay": 0.00021652597094420486, + "beta": 0.002114675155834881, + "latent_dim": 5, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2271, + "n_layers": 4, + "enc_factor": 1.168749231300563, + "batch_size": 131, + "learning_rate": 0.04730068128125773, + "drop_p": 0.015469379035717634, + "weight_decay": 0.0002570605979151856, + "beta": 0.9872007685876839, + "latent_dim": 8, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 176, + "n_layers": 4, + "enc_factor": 1.0561596690515722, + "batch_size": 214, + "learning_rate": 0.004773080872423022, + "drop_p": 0.09972254590615591, + "weight_decay": 9.527996948987185e-05, + "beta": 1.2324961514415171, + "latent_dim": 63, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1381, + "n_layers": 4, + "enc_factor": 2.006865679679904, + "batch_size": 208, + "learning_rate": 0.005128176991220945, + "drop_p": 0.48024067172105195, + "weight_decay": 0.00014805922746596054, + "beta": 0.560271360491952, + "latent_dim": 20, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 446, + "n_layers": 3, + "enc_factor": 2.17976388783074, + "batch_size": 163, + "learning_rate": 0.08185375637678734, + "drop_p": 0.781678732506516, + "weight_decay": 1.2440673957319716e-05, + "beta": 0.001412198368263827, + "latent_dim": 2, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 149, + "n_layers": 3, + "enc_factor": 1.548447520374335, + "batch_size": 35, + "learning_rate": 0.018974403981052556, + "drop_p": 0.20414952625718172, + "weight_decay": 0.00033150044408647656, + "beta": 0.0024933761281185803, + "latent_dim": 29, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1097, + "n_layers": 3, + "enc_factor": 1.9789182050360634, + "batch_size": 118, + "learning_rate": 0.00023730695424793252, + "drop_p": 0.25686231601313136, + "weight_decay": 0.012748664717787303, + "beta": 1.1390499565396621, + "latent_dim": 63, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2469, + "n_layers": 4, + "enc_factor": 1.1929615643109468, + "batch_size": 242, + "learning_rate": 0.004341438681640124, + "drop_p": 0.5215034662766506, + "weight_decay": 2.9851484501323253e-05, + "beta": 1.3698720016905042, + "latent_dim": 14, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 445, + "n_layers": 2, + "enc_factor": 3.2084477718747966, + "batch_size": 249, + "learning_rate": 0.0038594119831186274, + "drop_p": 0.2469417285937473, + "weight_decay": 1.135466430653325e-05, + "beta": 0.006957802575923246, + "latent_dim": 20, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3824, + "n_layers": 2, + "enc_factor": 1.2567238075615235, + "batch_size": 251, + "learning_rate": 1.499720083323735e-05, + "drop_p": 0.23312696478438807, + "weight_decay": 0.0034693930611093353, + "beta": 0.07865315861474237, + "latent_dim": 37, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 135, + "n_layers": 4, + "enc_factor": 1.672568915870736, + "batch_size": 182, + "learning_rate": 0.0011176138997535067, + "drop_p": 0.24575425792908717, + "weight_decay": 0.0008191017193050384, + "beta": 0.0028998205966729914, + "latent_dim": 39, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2022, + "n_layers": 4, + "enc_factor": 2.0155198455319336, + "batch_size": 225, + "learning_rate": 0.0030548723647600287, + "drop_p": 0.3715142579202299, + "weight_decay": 2.885546162503296e-05, + "beta": 2.32194467149973, + "latent_dim": 36, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3359, + "n_layers": 2, + "enc_factor": 2.815108071408453, + "batch_size": 166, + "learning_rate": 2.4843606148586337e-05, + "drop_p": 0.2211914930783062, + "weight_decay": 0.01564458769534348, + "beta": 0.24565772031421618, + "latent_dim": 33, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2641, + "n_layers": 2, + "enc_factor": 3.6842379830662932, + "batch_size": 158, + "learning_rate": 0.003502989746466495, + "drop_p": 0.27608935695985753, + "weight_decay": 2.015580398328973e-05, + "beta": 0.011619408969674718, + "latent_dim": 64, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 208, + "n_layers": 2, + "enc_factor": 2.098334817123243, + "batch_size": 202, + "learning_rate": 0.0026403593964580458, + "drop_p": 0.11522799060278488, + "weight_decay": 3.308533275010805e-05, + "beta": 0.0019439202685825482, + "latent_dim": 48, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 705, + "n_layers": 4, + "enc_factor": 2.004267583127013, + "batch_size": 168, + "learning_rate": 0.009618748194856083, + "drop_p": 0.03850815453907771, + "weight_decay": 8.473385466425422e-05, + "beta": 0.0022531531512423706, + "latent_dim": 23, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 649, + "n_layers": 3, + "enc_factor": 3.3650960483152015, + "batch_size": 174, + "learning_rate": 0.0032253549166879527, + "drop_p": 0.6157420654942333, + "weight_decay": 0.0018939536940859013, + "beta": 1.7653018583324633, + "latent_dim": 3, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 247, + "n_layers": 4, + "enc_factor": 1.7688856651583125, + "batch_size": 153, + "learning_rate": 0.02498400485621169, + "drop_p": 0.31867067280017214, + "weight_decay": 6.282302366346014e-05, + "beta": 0.6444131975648618, + "latent_dim": 54, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 442, + "n_layers": 4, + "enc_factor": 2.988905085243702, + "batch_size": 127, + "learning_rate": 0.038799022466077464, + "drop_p": 0.5388432071831087, + "weight_decay": 0.007189247776333977, + "beta": 0.007275061147263476, + "latent_dim": 19, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 144, + "n_layers": 4, + "enc_factor": 1.4842766276707615, + "batch_size": 160, + "learning_rate": 0.0009661836063947226, + "drop_p": 0.890130775649395, + "weight_decay": 7.845958762069749e-05, + "beta": 0.022853689006207226, + "latent_dim": 41, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3521, + "n_layers": 2, + "enc_factor": 1.5530195073020154, + "batch_size": 72, + "learning_rate": 0.00019884476958344468, + "drop_p": 0.5953053799530025, + "weight_decay": 0.0013657481344003673, + "beta": 0.3175054963731068, + "latent_dim": 40, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 212, + "n_layers": 3, + "enc_factor": 3.4682906515339673, + "batch_size": 207, + "learning_rate": 0.00018685879247853107, + "drop_p": 0.10227398655530699, + "weight_decay": 0.055593808515876635, + "beta": 0.002673755960378343, + "latent_dim": 47, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3606, + "n_layers": 3, + "enc_factor": 3.193697530139621, + "batch_size": 151, + "learning_rate": 0.0020021431892098965, + "drop_p": 0.2864503980804442, + "weight_decay": 0.012592517468648359, + "beta": 0.2855982146471407, + "latent_dim": 30, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 402, + "n_layers": 3, + "enc_factor": 2.868776717268729, + "batch_size": 181, + "learning_rate": 0.0909718493757559, + "drop_p": 0.16322821297222065, + "weight_decay": 0.00010391721121321809, + "beta": 0.001048218648136472, + "latent_dim": 32, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2779, + "n_layers": 4, + "enc_factor": 3.5832191133986795, + "batch_size": 133, + "learning_rate": 0.05082817374452234, + "drop_p": 0.6899433555566227, + "weight_decay": 0.00020480292033398233, + "beta": 0.020510720766777468, + "latent_dim": 48, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 374, + "n_layers": 2, + "enc_factor": 3.502176791152129, + "batch_size": 244, + "learning_rate": 0.001040234202162404, + "drop_p": 0.48048829736611165, + "weight_decay": 0.00011362563418147342, + "beta": 0.021430226658226244, + "latent_dim": 62, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 956, + "n_layers": 3, + "enc_factor": 2.123567363068779, + "batch_size": 212, + "learning_rate": 0.0024722885026139756, + "drop_p": 0.08725919297425928, + "weight_decay": 0.0023561896460946898, + "beta": 0.003161008869603176, + "latent_dim": 19, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 339, + "n_layers": 3, + "enc_factor": 1.5130776671751114, + "batch_size": 255, + "learning_rate": 0.001434360767015836, + "drop_p": 0.5854047961197631, + "weight_decay": 2.7976623331163867e-05, + "beta": 0.006388508508142814, + "latent_dim": 38, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 292, + "n_layers": 4, + "enc_factor": 3.8878800039421106, + "batch_size": 170, + "learning_rate": 0.0025086415888163635, + "drop_p": 0.6910074758092718, + "weight_decay": 0.0005187763637563948, + "beta": 0.030966100388928827, + "latent_dim": 37, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 188, + "n_layers": 4, + "enc_factor": 2.281843502135188, + "batch_size": 220, + "learning_rate": 0.001103844714588358, + "drop_p": 0.09139814131520799, + "weight_decay": 0.03211794007625899, + "beta": 0.0044872570683808025, + "latent_dim": 35, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2823, + "n_layers": 4, + "enc_factor": 1.3061028031229385, + "batch_size": 248, + "learning_rate": 7.426233475849165e-05, + "drop_p": 0.8434739261297357, + "weight_decay": 0.010308613941391919, + "beta": 0.6510181852016816, + "latent_dim": 15, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3231, + "n_layers": 3, + "enc_factor": 2.0806173569639883, + "batch_size": 88, + "learning_rate": 4.0496743663175365e-05, + "drop_p": 0.3455781505226911, + "weight_decay": 0.05312631731203732, + "beta": 5.601628254104207, + "latent_dim": 29, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2126, + "n_layers": 3, + "enc_factor": 2.15507219057434, + "batch_size": 171, + "learning_rate": 0.0007151756207195252, + "drop_p": 0.8210478511823567, + "weight_decay": 2.556878506597936e-05, + "beta": 6.853482128108972, + "latent_dim": 9, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1124, + "n_layers": 3, + "enc_factor": 1.349366408320662, + "batch_size": 60, + "learning_rate": 0.014401274257636557, + "drop_p": 0.6391390750317719, + "weight_decay": 0.029862957143341192, + "beta": 0.750047459460874, + "latent_dim": 32, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 252, + "n_layers": 2, + "enc_factor": 3.273582767394551, + "batch_size": 70, + "learning_rate": 0.0003464179706527937, + "drop_p": 0.26528476694552233, + "weight_decay": 1.6780245365542105e-05, + "beta": 0.0010156849630518284, + "latent_dim": 52, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 421, + "n_layers": 3, + "enc_factor": 1.3430938256097098, + "batch_size": 102, + "learning_rate": 1.8776505408563187e-05, + "drop_p": 0.4090156488105006, + "weight_decay": 0.00014276187248704725, + "beta": 0.010004592031901786, + "latent_dim": 45, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 198, + "n_layers": 2, + "enc_factor": 3.2661354458688385, + "batch_size": 100, + "learning_rate": 0.00016923989171858502, + "drop_p": 0.8469707558777452, + "weight_decay": 0.05712085036002799, + "beta": 6.935278784205936, + "latent_dim": 22, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 386, + "n_layers": 3, + "enc_factor": 2.8273484137234797, + "batch_size": 63, + "learning_rate": 0.001509440656605219, + "drop_p": 0.02977376982960487, + "weight_decay": 0.09491574499174295, + "beta": 0.03448237988453864, + "latent_dim": 37, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 635, + "n_layers": 3, + "enc_factor": 1.678219821494545, + "batch_size": 75, + "learning_rate": 8.070181069529435e-05, + "drop_p": 0.11824890815552468, + "weight_decay": 2.5295365829762406e-05, + "beta": 0.004228465968782208, + "latent_dim": 9, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3380, + "n_layers": 3, + "enc_factor": 3.9187311975256924, + "batch_size": 221, + "learning_rate": 6.31066193493105e-05, + "drop_p": 0.6243723754860858, + "weight_decay": 0.005363794786963421, + "beta": 0.007275941152978669, + "latent_dim": 56, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 236, + "n_layers": 4, + "enc_factor": 1.2876927055323315, + "batch_size": 33, + "learning_rate": 3.742801164600413e-05, + "drop_p": 0.1943319957961131, + "weight_decay": 0.002095247693787078, + "beta": 0.07761634183904065, + "latent_dim": 16, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 490, + "n_layers": 4, + "enc_factor": 2.1413890925229313, + "batch_size": 185, + "learning_rate": 0.01168218274924189, + "drop_p": 0.31644931015114736, + "weight_decay": 0.010323911316759273, + "beta": 0.25037071385797155, + "latent_dim": 3, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1139, + "n_layers": 3, + "enc_factor": 2.790468504073754, + "batch_size": 81, + "learning_rate": 0.062467673779033984, + "drop_p": 0.7785394913559479, + "weight_decay": 2.047453779850195e-05, + "beta": 0.0015050292694777207, + "latent_dim": 25, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 4062, + "n_layers": 2, + "enc_factor": 2.072120444270083, + "batch_size": 251, + "learning_rate": 2.7401906131035762e-05, + "drop_p": 0.0671256075369011, + "weight_decay": 0.0005328240117142471, + "beta": 0.5970796428602128, + "latent_dim": 30, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 454, + "n_layers": 3, + "enc_factor": 1.2451401219418932, + "batch_size": 36, + "learning_rate": 5.13197301553295e-05, + "drop_p": 0.002088635549006712, + "weight_decay": 0.0027644625197107203, + "beta": 0.004202479387366309, + "latent_dim": 53, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1978, + "n_layers": 4, + "enc_factor": 2.4872504203427193, + "batch_size": 89, + "learning_rate": 0.00017783753933701488, + "drop_p": 0.35324985602123954, + "weight_decay": 9.625134216902091e-05, + "beta": 0.08691633711045092, + "latent_dim": 57, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 202, + "n_layers": 4, + "enc_factor": 1.435669592974765, + "batch_size": 194, + "learning_rate": 0.017617623826391843, + "drop_p": 0.39538837756006656, + "weight_decay": 2.9900484987665135e-05, + "beta": 0.019624753636731353, + "latent_dim": 44, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3733, + "n_layers": 2, + "enc_factor": 2.850128957824065, + "batch_size": 159, + "learning_rate": 0.01288583673092654, + "drop_p": 0.6597719781715752, + "weight_decay": 0.0030733176037997783, + "beta": 2.536589513510022, + "latent_dim": 63, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + }, + "schc": { + "downstream": [ + { + "k_filter": 4071, + "n_layers": 3, + "enc_factor": 2.991360983156456, + "batch_size": 163, + "learning_rate": 0.005470931329674574, + "drop_p": 0.34691862851777167, + "weight_decay": 0.020878426850821696, + "beta": 0.0011136247438716215, + "latent_dim": 33, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3864, + "n_layers": 3, + "enc_factor": 1.9532548625454262, + "batch_size": 65, + "learning_rate": 0.0003051349543878214, + "drop_p": 0.22430747689735167, + "weight_decay": 0.004435406579930988, + "beta": 4.732280461428147, + "latent_dim": 21, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2882, + "n_layers": 4, + "enc_factor": 3.288474306676977, + "batch_size": 132, + "learning_rate": 0.00042030626820115005, + "drop_p": 0.5146156576126147, + "weight_decay": 0.018414237497533483, + "beta": 0.11830779513921982, + "latent_dim": 34, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2613, + "n_layers": 3, + "enc_factor": 3.9152841513625827, + "batch_size": 82, + "learning_rate": 0.0022162826824758067, + "drop_p": 0.15982330578293955, + "weight_decay": 0.05916840839784764, + "beta": 0.0010137027733487954, + "latent_dim": 57, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2286, + "n_layers": 3, + "enc_factor": 3.1983532214231882, + "batch_size": 56, + "learning_rate": 0.0004806945114226708, + "drop_p": 0.031313563157298496, + "weight_decay": 0.0005162617368378754, + "beta": 0.0058518605318232005, + "latent_dim": 46, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1659, + "n_layers": 2, + "enc_factor": 2.286567443701279, + "batch_size": 207, + "learning_rate": 0.015278059870218182, + "drop_p": 0.7790531241904309, + "weight_decay": 0.00031923710444524997, + "beta": 0.6861577344163164, + "latent_dim": 40, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1927, + "n_layers": 3, + "enc_factor": 3.7007406188227465, + "batch_size": 196, + "learning_rate": 1.5714228946838012e-05, + "drop_p": 0.7680845657693307, + "weight_decay": 0.003022237108400646, + "beta": 0.0059615427428752294, + "latent_dim": 62, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3227, + "n_layers": 3, + "enc_factor": 1.4028309725382426, + "batch_size": 243, + "learning_rate": 0.0016611765331817838, + "drop_p": 0.23103528153402877, + "weight_decay": 0.03195739247395453, + "beta": 0.0026447320304689723, + "latent_dim": 56, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1424, + "n_layers": 4, + "enc_factor": 3.045059729283646, + "batch_size": 244, + "learning_rate": 0.003757115014122458, + "drop_p": 0.4533101860996479, + "weight_decay": 0.00400872326844604, + "beta": 0.0011410511470671277, + "latent_dim": 35, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1256, + "n_layers": 3, + "enc_factor": 2.8678626220351227, + "batch_size": 95, + "learning_rate": 0.00032749868997337885, + "drop_p": 0.006071949213399386, + "weight_decay": 0.0012351484672465227, + "beta": 0.0060618795321681325, + "latent_dim": 57, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 494, + "n_layers": 2, + "enc_factor": 3.80065672274109, + "batch_size": 151, + "learning_rate": 0.002418653494093886, + "drop_p": 0.006327053099049041, + "weight_decay": 0.00019803630425071063, + "beta": 1.884943570241343, + "latent_dim": 22, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 142, + "n_layers": 2, + "enc_factor": 1.5833563444220111, + "batch_size": 42, + "learning_rate": 0.036205357920232994, + "drop_p": 0.08814559334266972, + "weight_decay": 0.0030122128778193214, + "beta": 0.04129538498700408, + "latent_dim": 7, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1631, + "n_layers": 2, + "enc_factor": 3.234887393580453, + "batch_size": 55, + "learning_rate": 0.02166732117402917, + "drop_p": 0.18735171780945473, + "weight_decay": 1.1940253261067021e-05, + "beta": 3.1794405176799105, + "latent_dim": 57, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 229, + "n_layers": 2, + "enc_factor": 1.8755844836458033, + "batch_size": 125, + "learning_rate": 0.008933904337394364, + "drop_p": 0.024366495678709833, + "weight_decay": 2.9816369617846625e-05, + "beta": 0.10739325619466054, + "latent_dim": 64, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1143, + "n_layers": 3, + "enc_factor": 2.939299717755371, + "batch_size": 33, + "learning_rate": 0.00999324540862066, + "drop_p": 0.8477164042542286, + "weight_decay": 0.057861730135109764, + "beta": 0.0030094238864134533, + "latent_dim": 27, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 145, + "n_layers": 2, + "enc_factor": 3.0050280713855377, + "batch_size": 39, + "learning_rate": 3.782376854068511e-05, + "drop_p": 0.6045237355951575, + "weight_decay": 1.8749684404892747e-05, + "beta": 0.0014369221313827712, + "latent_dim": 52, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 153, + "n_layers": 4, + "enc_factor": 3.0573313613947453, + "batch_size": 114, + "learning_rate": 0.003113877043893783, + "drop_p": 0.32982682767496535, + "weight_decay": 0.017343157982678575, + "beta": 0.009901681115502407, + "latent_dim": 4, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 205, + "n_layers": 2, + "enc_factor": 3.305066662240793, + "batch_size": 45, + "learning_rate": 0.008177118538958, + "drop_p": 0.03453087128883647, + "weight_decay": 0.059726153343186796, + "beta": 0.06750228791204863, + "latent_dim": 26, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 845, + "n_layers": 4, + "enc_factor": 2.333603574392862, + "batch_size": 189, + "learning_rate": 0.0001593012988104727, + "drop_p": 0.3502427656437035, + "weight_decay": 0.0002505878929453841, + "beta": 0.29860732360360087, + "latent_dim": 45, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1124, + "n_layers": 3, + "enc_factor": 2.3848257594988787, + "batch_size": 130, + "learning_rate": 0.006025635227407864, + "drop_p": 0.7703321552981823, + "weight_decay": 3.8953262989744095e-05, + "beta": 1.620423978324673, + "latent_dim": 20, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 245, + "n_layers": 3, + "enc_factor": 1.8955224568009679, + "batch_size": 60, + "learning_rate": 0.01252810233807698, + "drop_p": 0.45379930418204417, + "weight_decay": 0.008691564694735796, + "beta": 0.008129188621119731, + "latent_dim": 9, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1641, + "n_layers": 4, + "enc_factor": 3.0459633869774883, + "batch_size": 226, + "learning_rate": 0.00506496337831816, + "drop_p": 0.396507872216555, + "weight_decay": 0.002689078423192595, + "beta": 0.00575874355101996, + "latent_dim": 47, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1608, + "n_layers": 2, + "enc_factor": 2.355349149553442, + "batch_size": 121, + "learning_rate": 0.000512176567887601, + "drop_p": 0.11108240710087872, + "weight_decay": 0.0005180259558224786, + "beta": 0.006281651654374826, + "latent_dim": 64, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 160, + "n_layers": 3, + "enc_factor": 1.5485696280666543, + "batch_size": 150, + "learning_rate": 0.000672314173845224, + "drop_p": 0.03899754070108269, + "weight_decay": 0.054109472782854696, + "beta": 0.0011823655737027575, + "latent_dim": 8, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 4077, + "n_layers": 3, + "enc_factor": 3.761338381158874, + "batch_size": 84, + "learning_rate": 0.01117192843837208, + "drop_p": 0.46174867149082466, + "weight_decay": 1.1322444429750139e-05, + "beta": 0.027624960353033436, + "latent_dim": 33, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 130, + "n_layers": 3, + "enc_factor": 1.7308490941411736, + "batch_size": 207, + "learning_rate": 4.7525485470489414e-05, + "drop_p": 0.8522909979550671, + "weight_decay": 6.190436128374334e-05, + "beta": 0.004912110631031477, + "latent_dim": 62, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 207, + "n_layers": 3, + "enc_factor": 1.8698215383279515, + "batch_size": 230, + "learning_rate": 0.0012558447640674485, + "drop_p": 0.2040971612071011, + "weight_decay": 8.4193799703375e-05, + "beta": 0.06434670142598689, + "latent_dim": 41, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 819, + "n_layers": 4, + "enc_factor": 3.877794250211016, + "batch_size": 253, + "learning_rate": 0.000936767338225941, + "drop_p": 0.5099299510056989, + "weight_decay": 0.0023092786169825806, + "beta": 0.030412791402106093, + "latent_dim": 44, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2664, + "n_layers": 3, + "enc_factor": 3.2967362382712375, + "batch_size": 240, + "learning_rate": 0.000861799158567437, + "drop_p": 0.4562167528675056, + "weight_decay": 0.0001240985080042941, + "beta": 0.15636911984905988, + "latent_dim": 52, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 222, + "n_layers": 3, + "enc_factor": 1.5166797661818645, + "batch_size": 58, + "learning_rate": 0.00013852318413185526, + "drop_p": 0.05411497592657016, + "weight_decay": 0.00146763670779259, + "beta": 0.46351899384850725, + "latent_dim": 60, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 289, + "n_layers": 2, + "enc_factor": 3.760511949169538, + "batch_size": 35, + "learning_rate": 9.995603601403507e-05, + "drop_p": 0.07953855791475999, + "weight_decay": 2.084128554078676e-05, + "beta": 0.009430566045083586, + "latent_dim": 39, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 137, + "n_layers": 2, + "enc_factor": 1.2956662488330148, + "batch_size": 100, + "learning_rate": 2.7010022194197076e-05, + "drop_p": 0.0025248422261441752, + "weight_decay": 8.899128478061497e-05, + "beta": 0.0014422323287801707, + "latent_dim": 43, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2881, + "n_layers": 2, + "enc_factor": 2.8250842225378734, + "batch_size": 120, + "learning_rate": 2.647660204297023e-05, + "drop_p": 0.44166738102548503, + "weight_decay": 0.07628102880093256, + "beta": 0.5686296406276489, + "latent_dim": 3, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 241, + "n_layers": 3, + "enc_factor": 1.7089705717162063, + "batch_size": 138, + "learning_rate": 0.0007534217213172753, + "drop_p": 0.0888891552805707, + "weight_decay": 0.006279785539906185, + "beta": 0.0012367509152856973, + "latent_dim": 27, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 364, + "n_layers": 4, + "enc_factor": 1.607562919797279, + "batch_size": 67, + "learning_rate": 0.00161139428049655, + "drop_p": 0.7705915521136315, + "weight_decay": 2.359796807163846e-05, + "beta": 0.009975119135899031, + "latent_dim": 14, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 235, + "n_layers": 4, + "enc_factor": 1.4370258205868058, + "batch_size": 123, + "learning_rate": 0.0008018349131747344, + "drop_p": 0.5767718960925313, + "weight_decay": 0.0011780114067040872, + "beta": 0.0015309289424022996, + "latent_dim": 56, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 587, + "n_layers": 3, + "enc_factor": 1.1734104584556317, + "batch_size": 152, + "learning_rate": 0.007264034053544986, + "drop_p": 0.5912887098768342, + "weight_decay": 0.008289840127933613, + "beta": 0.023080681063902254, + "latent_dim": 58, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 242, + "n_layers": 3, + "enc_factor": 1.0431765976208718, + "batch_size": 121, + "learning_rate": 5.41340185638127e-05, + "drop_p": 0.09841628902393565, + "weight_decay": 0.0012519843827058915, + "beta": 2.1481557367678024, + "latent_dim": 8, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 401, + "n_layers": 2, + "enc_factor": 1.3038274863644013, + "batch_size": 33, + "learning_rate": 1.189970679240987e-05, + "drop_p": 0.5542752075949692, + "weight_decay": 0.022778890284042615, + "beta": 1.062020692474425, + "latent_dim": 52, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 178, + "n_layers": 3, + "enc_factor": 1.4083789473829285, + "batch_size": 164, + "learning_rate": 2.4561540596246873e-05, + "drop_p": 0.20211553335334934, + "weight_decay": 0.001228285485385054, + "beta": 6.300586949800689, + "latent_dim": 5, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 159, + "n_layers": 2, + "enc_factor": 1.6505687617824574, + "batch_size": 220, + "learning_rate": 0.0001450714161393783, + "drop_p": 0.5874740880310136, + "weight_decay": 0.0001258489153090472, + "beta": 3.460804125527492, + "latent_dim": 3, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2942, + "n_layers": 2, + "enc_factor": 3.741995524913239, + "batch_size": 153, + "learning_rate": 0.008211734284060343, + "drop_p": 0.0924830759291924, + "weight_decay": 0.0009617811716083348, + "beta": 0.01650201834066206, + "latent_dim": 57, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 802, + "n_layers": 2, + "enc_factor": 2.0381546084873134, + "batch_size": 139, + "learning_rate": 0.022290251588617024, + "drop_p": 0.8150672110622733, + "weight_decay": 1.3375776412047254e-05, + "beta": 9.287634142821183, + "latent_dim": 13, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 196, + "n_layers": 3, + "enc_factor": 2.4729779581159868, + "batch_size": 91, + "learning_rate": 6.121882644020465e-05, + "drop_p": 0.0600317874587547, + "weight_decay": 0.010254957339888354, + "beta": 0.08649970588487423, + "latent_dim": 49, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 191, + "n_layers": 3, + "enc_factor": 1.5754277549971514, + "batch_size": 171, + "learning_rate": 0.00012473911851111787, + "drop_p": 0.5165401800276321, + "weight_decay": 0.0012245183713711122, + "beta": 0.03992485909701446, + "latent_dim": 52, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1393, + "n_layers": 4, + "enc_factor": 1.346383066803221, + "batch_size": 150, + "learning_rate": 2.488610960982873e-05, + "drop_p": 0.7557548160997064, + "weight_decay": 6.408706335307643e-05, + "beta": 0.3870565152983639, + "latent_dim": 10, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 246, + "n_layers": 3, + "enc_factor": 3.3506787125306654, + "batch_size": 93, + "learning_rate": 0.0018677734399995545, + "drop_p": 0.04070190872509173, + "weight_decay": 0.00020916779704440095, + "beta": 0.01886934003056484, + "latent_dim": 17, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2540, + "n_layers": 4, + "enc_factor": 1.8271426258486545, + "batch_size": 163, + "learning_rate": 0.0030445699635795044, + "drop_p": 0.3768366971032114, + "weight_decay": 0.00024188725212687757, + "beta": 0.0044723585208713695, + "latent_dim": 51, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3728, + "n_layers": 2, + "enc_factor": 1.0582472634121647, + "batch_size": 127, + "learning_rate": 4.3065035515944733e-05, + "drop_p": 0.14547295503038365, + "weight_decay": 0.00041164529151305017, + "beta": 0.0017192170446316656, + "latent_dim": 7, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 255, + "n_layers": 4, + "enc_factor": 3.472939421367153, + "batch_size": 200, + "learning_rate": 0.020741586934362143, + "drop_p": 0.22139055739802546, + "weight_decay": 0.019625451086675325, + "beta": 0.0014315677544659584, + "latent_dim": 32, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 338, + "n_layers": 4, + "enc_factor": 3.441456371838502, + "batch_size": 236, + "learning_rate": 0.005610140575792183, + "drop_p": 0.4561189357080172, + "weight_decay": 0.004626651489970166, + "beta": 6.218939578028419, + "latent_dim": 30, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 212, + "n_layers": 4, + "enc_factor": 1.9644575582210104, + "batch_size": 146, + "learning_rate": 0.00037762766918759304, + "drop_p": 0.3007745565911309, + "weight_decay": 1.353849118237303e-05, + "beta": 0.0035715946056876285, + "latent_dim": 39, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2648, + "n_layers": 4, + "enc_factor": 3.3066059160800934, + "batch_size": 200, + "learning_rate": 0.0005134405414154806, + "drop_p": 0.25900681236124196, + "weight_decay": 0.00013468322277540202, + "beta": 0.0816655469780627, + "latent_dim": 5, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2918, + "n_layers": 2, + "enc_factor": 1.9097423855745355, + "batch_size": 131, + "learning_rate": 0.04719768407963293, + "drop_p": 0.06793491026334711, + "weight_decay": 0.00016673277631885062, + "beta": 0.9318329877131624, + "latent_dim": 29, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 224, + "n_layers": 3, + "enc_factor": 1.5055249360301435, + "batch_size": 172, + "learning_rate": 0.0033794794307922585, + "drop_p": 0.08429277547738566, + "weight_decay": 0.0029172582184346786, + "beta": 0.0011514969478183773, + "latent_dim": 56, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 466, + "n_layers": 2, + "enc_factor": 2.4259672744242673, + "batch_size": 216, + "learning_rate": 0.0017369074961255233, + "drop_p": 0.4648309465361431, + "weight_decay": 0.0014429619473411636, + "beta": 0.46933325923092745, + "latent_dim": 19, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 151, + "n_layers": 3, + "enc_factor": 2.4885155698012364, + "batch_size": 105, + "learning_rate": 0.00020784694126485873, + "drop_p": 0.49145619825323716, + "weight_decay": 0.0197899863126285, + "beta": 0.01149516247323542, + "latent_dim": 61, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2663, + "n_layers": 3, + "enc_factor": 3.577026243689478, + "batch_size": 79, + "learning_rate": 0.05615681358334665, + "drop_p": 0.4836923989586214, + "weight_decay": 0.005021990378862854, + "beta": 0.0265481750040546, + "latent_dim": 29, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 191, + "n_layers": 2, + "enc_factor": 3.166838500365489, + "batch_size": 177, + "learning_rate": 0.0033651436677166005, + "drop_p": 0.4574278449624893, + "weight_decay": 0.013055134363768593, + "beta": 3.6266866169491543, + "latent_dim": 54, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 232, + "n_layers": 2, + "enc_factor": 1.1558978404216067, + "batch_size": 146, + "learning_rate": 0.0006566273317085365, + "drop_p": 0.12012236889806847, + "weight_decay": 0.012719914575671686, + "beta": 0.0020045893978804822, + "latent_dim": 57, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 161, + "n_layers": 3, + "enc_factor": 3.786568044402622, + "batch_size": 90, + "learning_rate": 0.035985619444764624, + "drop_p": 0.23652623143507018, + "weight_decay": 0.036888584880969355, + "beta": 0.016451857625896765, + "latent_dim": 14, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 246, + "n_layers": 3, + "enc_factor": 1.8291189064673983, + "batch_size": 121, + "learning_rate": 0.009223376333333604, + "drop_p": 0.4931326759117245, + "weight_decay": 0.0647025784993547, + "beta": 0.0025560172030935054, + "latent_dim": 54, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1750, + "n_layers": 4, + "enc_factor": 2.2318838363142266, + "batch_size": 78, + "learning_rate": 0.06543729379472821, + "drop_p": 0.7792989906036286, + "weight_decay": 0.00011077697154669338, + "beta": 1.3518127067032195, + "latent_dim": 5, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 161, + "n_layers": 2, + "enc_factor": 2.178090106914372, + "batch_size": 166, + "learning_rate": 0.0005421573982409447, + "drop_p": 0.056540096286389264, + "weight_decay": 1.8082059471036742e-05, + "beta": 0.0017863405732952285, + "latent_dim": 46, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2018, + "n_layers": 3, + "enc_factor": 1.0549233160241904, + "batch_size": 48, + "learning_rate": 2.1058076696148927e-05, + "drop_p": 0.24935925422114225, + "weight_decay": 0.0021081128828144176, + "beta": 3.431636242511989, + "latent_dim": 54, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 471, + "n_layers": 2, + "enc_factor": 3.8716414574927707, + "batch_size": 49, + "learning_rate": 0.006128532866129199, + "drop_p": 0.09964348595290992, + "weight_decay": 0.001217599217055597, + "beta": 0.15545397918342824, + "latent_dim": 7, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 232, + "n_layers": 3, + "enc_factor": 2.5571377088542504, + "batch_size": 169, + "learning_rate": 0.020412058166490058, + "drop_p": 0.08882042773537946, + "weight_decay": 0.0301015167868148, + "beta": 0.001443774260955413, + "latent_dim": 23, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2411, + "n_layers": 3, + "enc_factor": 3.732476498018877, + "batch_size": 56, + "learning_rate": 0.05307988135800361, + "drop_p": 0.8157985781328886, + "weight_decay": 1.334368858313261e-05, + "beta": 1.3218049705922668, + "latent_dim": 6, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3930, + "n_layers": 4, + "enc_factor": 3.7425673735086495, + "batch_size": 230, + "learning_rate": 0.00019569500661647025, + "drop_p": 0.16769657203750557, + "weight_decay": 0.06105939163461944, + "beta": 4.742824420001074, + "latent_dim": 27, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 177, + "n_layers": 3, + "enc_factor": 2.611221659262482, + "batch_size": 252, + "learning_rate": 0.00032702151205381475, + "drop_p": 0.15456345767603577, + "weight_decay": 0.0020138312462322006, + "beta": 0.001107254755215972, + "latent_dim": 19, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 443, + "n_layers": 2, + "enc_factor": 3.7156202179832873, + "batch_size": 237, + "learning_rate": 0.01189493617770607, + "drop_p": 0.052786720277600056, + "weight_decay": 0.001728343315126961, + "beta": 0.0872411473373692, + "latent_dim": 20, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 186, + "n_layers": 3, + "enc_factor": 1.2173791487862622, + "batch_size": 180, + "learning_rate": 9.720073249227248e-05, + "drop_p": 0.4872490739403024, + "weight_decay": 0.0012561985844895993, + "beta": 0.002268605268220012, + "latent_dim": 43, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 230, + "n_layers": 3, + "enc_factor": 1.654426767120001, + "batch_size": 37, + "learning_rate": 2.2560737357350678e-05, + "drop_p": 0.5632466964748759, + "weight_decay": 0.0015292637443152701, + "beta": 0.012423538760245597, + "latent_dim": 57, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3300, + "n_layers": 3, + "enc_factor": 2.5546241659365436, + "batch_size": 84, + "learning_rate": 0.08556505956261803, + "drop_p": 0.33686239212228847, + "weight_decay": 0.0011474217377208155, + "beta": 5.238533520748681, + "latent_dim": 27, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1701, + "n_layers": 4, + "enc_factor": 2.84243302152741, + "batch_size": 83, + "learning_rate": 0.007880265654084612, + "drop_p": 0.7401101119308188, + "weight_decay": 6.798280982372848e-05, + "beta": 0.0026876170208521184, + "latent_dim": 7, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 691, + "n_layers": 2, + "enc_factor": 2.643533498997715, + "batch_size": 121, + "learning_rate": 0.00015102495486071327, + "drop_p": 0.3833558068898636, + "weight_decay": 0.004473640671784279, + "beta": 0.00104676626583321, + "latent_dim": 14, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 209, + "n_layers": 3, + "enc_factor": 1.1832393667495134, + "batch_size": 82, + "learning_rate": 0.0005191091815219082, + "drop_p": 0.355771229306076, + "weight_decay": 0.0001691630497559903, + "beta": 0.0016749956739397303, + "latent_dim": 38, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2463, + "n_layers": 2, + "enc_factor": 1.2252398510661604, + "batch_size": 174, + "learning_rate": 0.005912065613041659, + "drop_p": 0.34150141478118395, + "weight_decay": 5.708152988694784e-05, + "beta": 0.11782434556116415, + "latent_dim": 25, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2509, + "n_layers": 4, + "enc_factor": 1.214975507887604, + "batch_size": 212, + "learning_rate": 0.0015968891303087514, + "drop_p": 0.23501460876573008, + "weight_decay": 0.0007305952201234296, + "beta": 0.0023738456276812463, + "latent_dim": 12, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 300, + "n_layers": 3, + "enc_factor": 3.514360557525505, + "batch_size": 208, + "learning_rate": 0.0007142594529218329, + "drop_p": 0.13143847469553624, + "weight_decay": 0.005830263162848254, + "beta": 0.776016566104636, + "latent_dim": 52, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + } + }, + "ontix": { + "combined": { + "downstream": [ + { + "k_filter": 430, + "n_layers": 2, + "enc_factor": 2.7967098234935146, + "batch_size": 123, + "learning_rate": 2.8959886980621284e-05, + "drop_p": 0.4930141128133946, + "weight_decay": 0.07067002184245229, + "beta": 0.0007123178945740746, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3083, + "n_layers": 3, + "enc_factor": 3.467335839270678, + "batch_size": 207, + "learning_rate": 0.0008667632932989543, + "drop_p": 0.7168809007497224, + "weight_decay": 0.0001181934148080836, + "beta": 0.0027725047382501722, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3927, + "n_layers": 2, + "enc_factor": 1.1731158200419864, + "batch_size": 225, + "learning_rate": 0.0005107633473867606, + "drop_p": 0.21953330723641648, + "weight_decay": 0.0013910968119045216, + "beta": 0.0006259973267310243, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1027, + "n_layers": 4, + "enc_factor": 2.4095117164891064, + "batch_size": 76, + "learning_rate": 0.00048226044403603963, + "drop_p": 0.5327059860076515, + "weight_decay": 0.006891935054491589, + "beta": 0.022511214482441293, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 903, + "n_layers": 2, + "enc_factor": 3.468934254421991, + "batch_size": 136, + "learning_rate": 0.047434611207868634, + "drop_p": 0.7086871874106613, + "weight_decay": 1.8886229170915397e-05, + "beta": 0.01205362036340203, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1079, + "n_layers": 3, + "enc_factor": 1.8313893298359245, + "batch_size": 56, + "learning_rate": 6.194242957795818e-05, + "drop_p": 0.009801999071090417, + "weight_decay": 0.003770549524237349, + "beta": 0.0008716537846973434, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 4093, + "n_layers": 3, + "enc_factor": 1.699828932408366, + "batch_size": 197, + "learning_rate": 0.0020122588103654655, + "drop_p": 0.7971345068789518, + "weight_decay": 0.0024379547585542502, + "beta": 0.3972343342231159, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 959, + "n_layers": 3, + "enc_factor": 3.0080451092507547, + "batch_size": 245, + "learning_rate": 1.0781626325857442e-05, + "drop_p": 0.4341214932282709, + "weight_decay": 0.0010039727353028118, + "beta": 0.1271226489015117, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1117, + "n_layers": 3, + "enc_factor": 1.8758034459863007, + "batch_size": 147, + "learning_rate": 0.0004941231581689414, + "drop_p": 0.36525923321744386, + "weight_decay": 1.2356925533848079e-05, + "beta": 0.00045496736756810727, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1801, + "n_layers": 4, + "enc_factor": 1.4001012495179896, + "batch_size": 115, + "learning_rate": 8.590433272552153e-05, + "drop_p": 0.24810955800093829, + "weight_decay": 0.00028756231045204726, + "beta": 0.0005848782417904078, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 1983, + "n_layers": 4, + "enc_factor": 3.4434495973905928, + "batch_size": 79, + "learning_rate": 0.00029260425567867796, + "drop_p": 0.8256140220083016, + "weight_decay": 3.8425748421110715e-05, + "beta": 0.025859236761509335, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 144, + "n_layers": 2, + "enc_factor": 3.8419562143378823, + "batch_size": 170, + "learning_rate": 0.021970968954424276, + "drop_p": 0.6837281485544145, + "weight_decay": 0.02821156919785431, + "beta": 0.013816042902794187, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3376, + "n_layers": 4, + "enc_factor": 3.424351008798094, + "batch_size": 78, + "learning_rate": 1.5177135735524128e-05, + "drop_p": 0.12184793673345529, + "weight_decay": 0.0002940632243092666, + "beta": 0.6651761326332194, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2482, + "n_layers": 4, + "enc_factor": 3.1544388484615746, + "batch_size": 249, + "learning_rate": 2.9824947122121404e-05, + "drop_p": 0.03463529307686686, + "weight_decay": 7.892337958506049e-05, + "beta": 0.010417677684885291, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 206, + "n_layers": 2, + "enc_factor": 2.808500764009093, + "batch_size": 159, + "learning_rate": 1.5603588615366707e-05, + "drop_p": 0.8314836839683146, + "weight_decay": 0.06643548156795039, + "beta": 0.03629760356556829, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 198, + "n_layers": 2, + "enc_factor": 3.54127225248588, + "batch_size": 206, + "learning_rate": 0.00027080760723951743, + "drop_p": 0.3402818111876917, + "weight_decay": 2.5650335857525388e-05, + "beta": 0.01989726624743026, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1372, + "n_layers": 2, + "enc_factor": 2.9136779008006717, + "batch_size": 195, + "learning_rate": 0.00011664155263081533, + "drop_p": 0.4890716118975691, + "weight_decay": 0.028900023230256075, + "beta": 0.017003826189577603, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1503, + "n_layers": 3, + "enc_factor": 3.0447309652834997, + "batch_size": 110, + "learning_rate": 3.177462987004317e-05, + "drop_p": 0.043301387422438935, + "weight_decay": 1.4085020686569125e-05, + "beta": 0.9283550595739277, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1174, + "n_layers": 3, + "enc_factor": 3.506457766813372, + "batch_size": 251, + "learning_rate": 3.579364097905784e-05, + "drop_p": 0.4231645283896032, + "weight_decay": 0.0066229682685168345, + "beta": 0.08353806945257891, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 208, + "n_layers": 4, + "enc_factor": 3.1923989794269447, + "batch_size": 224, + "learning_rate": 0.0003022955894971238, + "drop_p": 0.8734327586273245, + "weight_decay": 0.08168114968419488, + "beta": 0.01832287645806867, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 268, + "n_layers": 3, + "enc_factor": 1.8983326182932632, + "batch_size": 100, + "learning_rate": 0.00031348238764382, + "drop_p": 0.4308333043016589, + "weight_decay": 0.0010959136412531064, + "beta": 0.019880860251177898, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3668, + "n_layers": 3, + "enc_factor": 3.53272323133874, + "batch_size": 57, + "learning_rate": 2.5827389228800813e-05, + "drop_p": 0.3711807585428996, + "weight_decay": 0.0001119506119414896, + "beta": 0.002936174928854416, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2010, + "n_layers": 2, + "enc_factor": 3.8604263325734083, + "batch_size": 123, + "learning_rate": 0.008627322572466456, + "drop_p": 0.05219501216675202, + "weight_decay": 2.4311981110109633e-05, + "beta": 0.5300204126021126, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 4068, + "n_layers": 4, + "enc_factor": 1.792803300855746, + "batch_size": 212, + "learning_rate": 0.01431888042328161, + "drop_p": 0.7212317008055259, + "weight_decay": 0.000734200182870441, + "beta": 0.5727077730315187, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1902, + "n_layers": 4, + "enc_factor": 1.7825957731333668, + "batch_size": 62, + "learning_rate": 0.001864909813342794, + "drop_p": 0.5130732498941409, + "weight_decay": 0.004850854694634952, + "beta": 0.019496292041115124, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 133, + "n_layers": 3, + "enc_factor": 3.9131770146318914, + "batch_size": 155, + "learning_rate": 0.0002394337660295829, + "drop_p": 0.1828176385017484, + "weight_decay": 0.01919305670887493, + "beta": 0.00015224593305977982, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3056, + "n_layers": 4, + "enc_factor": 3.3895367676703367, + "batch_size": 95, + "learning_rate": 0.010902891651284243, + "drop_p": 0.15983214503528373, + "weight_decay": 1.95100504663584e-05, + "beta": 0.00015867425815106135, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2756, + "n_layers": 4, + "enc_factor": 2.035524565209105, + "batch_size": 216, + "learning_rate": 3.35974780573131e-05, + "drop_p": 0.59614146119782, + "weight_decay": 0.0009728861955991256, + "beta": 0.0030917880474340977, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 676, + "n_layers": 3, + "enc_factor": 2.5130921441788447, + "batch_size": 32, + "learning_rate": 0.00011614502342970615, + "drop_p": 0.6246969363148365, + "weight_decay": 0.00012178138124643453, + "beta": 0.00013426556664979477, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 132, + "n_layers": 3, + "enc_factor": 2.909658449822138, + "batch_size": 253, + "learning_rate": 0.0005997157821869551, + "drop_p": 0.2660772953043488, + "weight_decay": 1.5337802008684445e-05, + "beta": 0.0004609311396706325, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 857, + "n_layers": 3, + "enc_factor": 2.3834575923870136, + "batch_size": 193, + "learning_rate": 0.008133553955285717, + "drop_p": 0.14375318748798965, + "weight_decay": 0.0010275484339489708, + "beta": 0.0004420735565238346, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1288, + "n_layers": 3, + "enc_factor": 3.813725450048993, + "batch_size": 231, + "learning_rate": 2.0459645779380703e-05, + "drop_p": 0.5308881029608326, + "weight_decay": 0.02492683822314823, + "beta": 0.6325021968716752, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1546, + "n_layers": 3, + "enc_factor": 3.744824331645118, + "batch_size": 199, + "learning_rate": 0.0797257273852417, + "drop_p": 0.18108535278829066, + "weight_decay": 0.06700486637674943, + "beta": 0.00038773160610193827, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1853, + "n_layers": 2, + "enc_factor": 2.6262771037262493, + "batch_size": 126, + "learning_rate": 1.6170415263494028e-05, + "drop_p": 0.7761019630065268, + "weight_decay": 0.02600588541038575, + "beta": 0.0057938394577236995, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3643, + "n_layers": 3, + "enc_factor": 2.7434723818053413, + "batch_size": 214, + "learning_rate": 0.0981392475800317, + "drop_p": 0.7929330030836247, + "weight_decay": 0.018606732704992197, + "beta": 0.0017880937418924374, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3982, + "n_layers": 3, + "enc_factor": 2.5288263828958915, + "batch_size": 41, + "learning_rate": 0.08797700903592579, + "drop_p": 0.2860917534940542, + "weight_decay": 0.009636226781119946, + "beta": 0.005766221898133145, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 538, + "n_layers": 2, + "enc_factor": 2.827686972898934, + "batch_size": 126, + "learning_rate": 0.022977087208917165, + "drop_p": 0.1508223019781999, + "weight_decay": 0.0040461951410941015, + "beta": 0.0009978165946806698, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1949, + "n_layers": 2, + "enc_factor": 3.5547588002557724, + "batch_size": 34, + "learning_rate": 0.0008569271507338041, + "drop_p": 0.7168912025942469, + "weight_decay": 0.0003782229693488127, + "beta": 0.0034665679431575462, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 174, + "n_layers": 3, + "enc_factor": 1.7541798963643682, + "batch_size": 214, + "learning_rate": 0.013949030603083099, + "drop_p": 0.6245277552299415, + "weight_decay": 1.1963686483082524e-05, + "beta": 0.0012564342508717067, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2708, + "n_layers": 3, + "enc_factor": 3.637227820215834, + "batch_size": 137, + "learning_rate": 0.0014038649941216792, + "drop_p": 0.41215749962424025, + "weight_decay": 0.0001523955360764188, + "beta": 0.0009891368490265763, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 827, + "n_layers": 4, + "enc_factor": 3.0058365286282136, + "batch_size": 147, + "learning_rate": 6.724431118962159e-05, + "drop_p": 0.38702422196266106, + "weight_decay": 0.007905228559479532, + "beta": 0.049532604810301785, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3909, + "n_layers": 3, + "enc_factor": 3.7666721967267454, + "batch_size": 242, + "learning_rate": 0.00030019816268794694, + "drop_p": 0.43948981430025424, + "weight_decay": 0.007564291181301087, + "beta": 0.00012606878545506786, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 592, + "n_layers": 3, + "enc_factor": 1.0763324219025043, + "batch_size": 146, + "learning_rate": 0.00012353152670799427, + "drop_p": 0.8296215966973113, + "weight_decay": 0.04878040560448909, + "beta": 0.12071242821036116, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 174, + "n_layers": 2, + "enc_factor": 1.2314887118693312, + "batch_size": 107, + "learning_rate": 0.0014699816780016058, + "drop_p": 0.8587691143917012, + "weight_decay": 1.0642082911461245e-05, + "beta": 0.00011855311022806233, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1536, + "n_layers": 2, + "enc_factor": 1.2591252317653856, + "batch_size": 59, + "learning_rate": 8.265691760812257e-05, + "drop_p": 0.14854060922539464, + "weight_decay": 0.00016383395022225218, + "beta": 0.004640564806684275, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1089, + "n_layers": 4, + "enc_factor": 3.454752730886012, + "batch_size": 178, + "learning_rate": 7.902044239704471e-05, + "drop_p": 0.5368563495922765, + "weight_decay": 0.04515694034582963, + "beta": 0.006581254939027435, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1551, + "n_layers": 4, + "enc_factor": 3.5734009505997752, + "batch_size": 35, + "learning_rate": 0.030074921598913156, + "drop_p": 0.6018344309813044, + "weight_decay": 0.0004106548090162074, + "beta": 0.00043411054587645973, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1242, + "n_layers": 3, + "enc_factor": 1.9457929040972322, + "batch_size": 222, + "learning_rate": 0.01953265171543353, + "drop_p": 0.2091906212425906, + "weight_decay": 5.4682489001910134e-05, + "beta": 0.001278204204170475, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1206, + "n_layers": 4, + "enc_factor": 3.2698374123902583, + "batch_size": 116, + "learning_rate": 3.6232907408684916e-05, + "drop_p": 0.0009667988393985638, + "weight_decay": 6.0256694985871126e-05, + "beta": 0.12079945700983247, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1868, + "n_layers": 4, + "enc_factor": 2.8031986597590315, + "batch_size": 107, + "learning_rate": 0.09108496745073126, + "drop_p": 0.22402915240709018, + "weight_decay": 0.0029347615566195587, + "beta": 0.07242944820652128, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 195, + "n_layers": 3, + "enc_factor": 1.9058478513721069, + "batch_size": 90, + "learning_rate": 0.00012045935840656184, + "drop_p": 0.16380835594482102, + "weight_decay": 0.00013944482830575232, + "beta": 0.38970298773751094, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1944, + "n_layers": 3, + "enc_factor": 3.0302907124874903, + "batch_size": 221, + "learning_rate": 0.0001416440522517966, + "drop_p": 0.8418473807516862, + "weight_decay": 0.05362758009073276, + "beta": 0.20856207866321902, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3406, + "n_layers": 2, + "enc_factor": 3.763305337405984, + "batch_size": 175, + "learning_rate": 0.007644031536749677, + "drop_p": 0.3637514017125643, + "weight_decay": 8.208894148388921e-05, + "beta": 0.8517221795374088, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 723, + "n_layers": 2, + "enc_factor": 3.1362781865615146, + "batch_size": 154, + "learning_rate": 0.0002462716363112615, + "drop_p": 0.3027622958484158, + "weight_decay": 0.06055770239152793, + "beta": 0.008083856482813939, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2285, + "n_layers": 4, + "enc_factor": 1.010048965676661, + "batch_size": 183, + "learning_rate": 9.766536924306651e-05, + "drop_p": 0.058844864836880915, + "weight_decay": 0.06283395485998296, + "beta": 0.00019836530483147513, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 157, + "n_layers": 3, + "enc_factor": 3.5179705946477116, + "batch_size": 124, + "learning_rate": 0.00012060885753430365, + "drop_p": 0.6311649815095075, + "weight_decay": 0.014776289258563611, + "beta": 0.00057194052249169, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 234, + "n_layers": 3, + "enc_factor": 1.1392269252342835, + "batch_size": 192, + "learning_rate": 2.1162393876904713e-05, + "drop_p": 0.07775434416365787, + "weight_decay": 1.1298304307450101e-05, + "beta": 0.7678517235859228, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2526, + "n_layers": 2, + "enc_factor": 2.6394498745797166, + "batch_size": 46, + "learning_rate": 0.00011391926717258536, + "drop_p": 0.09421733832999805, + "weight_decay": 0.05677213683518166, + "beta": 0.26887536621633834, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 812, + "n_layers": 4, + "enc_factor": 2.353803804189433, + "batch_size": 34, + "learning_rate": 9.644743066237837e-05, + "drop_p": 0.7872818934620713, + "weight_decay": 1.3099756156325191e-05, + "beta": 0.4339032692135317, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3982, + "n_layers": 3, + "enc_factor": 1.4814983874713001, + "batch_size": 254, + "learning_rate": 0.00010752701533548713, + "drop_p": 0.8822653428970311, + "weight_decay": 0.0005996263125922243, + "beta": 0.1958804494901541, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 2311, + "n_layers": 2, + "enc_factor": 3.845448604506466, + "batch_size": 100, + "learning_rate": 1.2339396626268495e-05, + "drop_p": 0.7178373203160056, + "weight_decay": 1.3433278697591379e-05, + "beta": 0.7952847358226203, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2644, + "n_layers": 3, + "enc_factor": 2.3304131690458503, + "batch_size": 144, + "learning_rate": 0.058262347984861025, + "drop_p": 0.11782589365160623, + "weight_decay": 0.012000083936868994, + "beta": 0.0011624266856606028, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3226, + "n_layers": 3, + "enc_factor": 1.201340000360514, + "batch_size": 151, + "learning_rate": 0.06578088207566396, + "drop_p": 0.6959746195144115, + "weight_decay": 0.002508915238398635, + "beta": 0.00025115469901450504, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2561, + "n_layers": 3, + "enc_factor": 2.0564960513236596, + "batch_size": 218, + "learning_rate": 0.00012746987084482286, + "drop_p": 0.33839925281568317, + "weight_decay": 0.009554377154315088, + "beta": 0.14701701199469194, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 505, + "n_layers": 4, + "enc_factor": 1.2156510474756934, + "batch_size": 186, + "learning_rate": 0.06678167426016544, + "drop_p": 0.7097156117636146, + "weight_decay": 0.017121131821607124, + "beta": 0.02933649724396568, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1600, + "n_layers": 3, + "enc_factor": 2.2366161351110905, + "batch_size": 222, + "learning_rate": 2.886330138333214e-05, + "drop_p": 0.12988483932611838, + "weight_decay": 0.0004382827537968451, + "beta": 0.04842406281927623, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2620, + "n_layers": 3, + "enc_factor": 2.499933716992894, + "batch_size": 169, + "learning_rate": 8.135112852134134e-05, + "drop_p": 0.1385691602973624, + "weight_decay": 0.05055673832883864, + "beta": 0.000978367915378135, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 165, + "n_layers": 3, + "enc_factor": 3.175200780462088, + "batch_size": 208, + "learning_rate": 0.04524365573262143, + "drop_p": 0.8091004730133436, + "weight_decay": 3.6304734925190335e-05, + "beta": 0.00029678382293549, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2711, + "n_layers": 2, + "enc_factor": 3.335554093925269, + "batch_size": 215, + "learning_rate": 0.06661065854855071, + "drop_p": 0.5299058975059666, + "weight_decay": 0.0003244592566155311, + "beta": 0.008968796740044641, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3840, + "n_layers": 2, + "enc_factor": 1.39141373372615, + "batch_size": 109, + "learning_rate": 0.04890133204001136, + "drop_p": 0.023144067641247445, + "weight_decay": 0.00013675296053615262, + "beta": 0.015829976263071192, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 304, + "n_layers": 3, + "enc_factor": 2.341704316140305, + "batch_size": 218, + "learning_rate": 0.0008609676717266283, + "drop_p": 0.6776664642671985, + "weight_decay": 0.053032769305295636, + "beta": 0.00025031007813420766, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3723, + "n_layers": 4, + "enc_factor": 1.1084634878474933, + "batch_size": 252, + "learning_rate": 2.913620180057205e-05, + "drop_p": 0.289197912377796, + "weight_decay": 0.02151589212337751, + "beta": 0.02017933207355277, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2537, + "n_layers": 3, + "enc_factor": 1.741138563497684, + "batch_size": 113, + "learning_rate": 1.9664029108797312e-05, + "drop_p": 0.5375508874867455, + "weight_decay": 0.026911345673338572, + "beta": 0.013656067011705833, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 217, + "n_layers": 4, + "enc_factor": 3.6532549905560576, + "batch_size": 207, + "learning_rate": 0.0001491743730550704, + "drop_p": 0.6406509240614382, + "weight_decay": 0.0017383732303881273, + "beta": 0.0017502402617776392, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2322, + "n_layers": 4, + "enc_factor": 3.6698884471468682, + "batch_size": 159, + "learning_rate": 0.06372417231204548, + "drop_p": 0.14451381785459363, + "weight_decay": 2.3657795022781095e-05, + "beta": 0.4007042891158616, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 169, + "n_layers": 4, + "enc_factor": 2.8882162861087823, + "batch_size": 105, + "learning_rate": 0.001587030383275977, + "drop_p": 0.19609440053039373, + "weight_decay": 0.0007589492120812084, + "beta": 0.0041188926883186545, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1265, + "n_layers": 3, + "enc_factor": 3.9712901619982413, + "batch_size": 222, + "learning_rate": 0.0001706865272863917, + "drop_p": 0.8192041084541338, + "weight_decay": 0.020753837276887614, + "beta": 0.1214993889078168, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2730, + "n_layers": 3, + "enc_factor": 2.48268396382602, + "batch_size": 142, + "learning_rate": 0.01077925641085923, + "drop_p": 0.2208587466888485, + "weight_decay": 0.0009160989196704409, + "beta": 0.10491520091726428, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 764, + "n_layers": 4, + "enc_factor": 3.2959353951539674, + "batch_size": 137, + "learning_rate": 0.001579666134293918, + "drop_p": 0.6476001455987398, + "weight_decay": 0.019179001234947268, + "beta": 0.00011751485358645007, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3481, + "n_layers": 3, + "enc_factor": 2.875644614804054, + "batch_size": 242, + "learning_rate": 0.002562850511717365, + "drop_p": 0.2097633264281642, + "weight_decay": 0.0020642141644483815, + "beta": 0.028459937865630995, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + }, + "tcga": { + "downstream": [ + { + "k_filter": 2225, + "n_layers": 3, + "enc_factor": 1.1117736338707631, + "batch_size": 195, + "learning_rate": 0.0009853658486341473, + "drop_p": 0.06810793092593458, + "weight_decay": 0.09562968739463347, + "beta": 0.001939726772048429, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 473, + "n_layers": 2, + "enc_factor": 1.4127654252606336, + "batch_size": 156, + "learning_rate": 0.0020612331443380038, + "drop_p": 0.6483118234850282, + "weight_decay": 0.032660528870994486, + "beta": 0.0006030897323349734, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2257, + "n_layers": 3, + "enc_factor": 2.430347395171943, + "batch_size": 137, + "learning_rate": 0.00191088874742727, + "drop_p": 0.20592572321674113, + "weight_decay": 0.005788495285765509, + "beta": 0.006602868231062787, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1235, + "n_layers": 2, + "enc_factor": 1.1998888198078252, + "batch_size": 99, + "learning_rate": 0.0035236472060319497, + "drop_p": 0.6242466679407521, + "weight_decay": 1.828468103116793e-05, + "beta": 0.14530149039610474, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2339, + "n_layers": 4, + "enc_factor": 1.5580449788718584, + "batch_size": 113, + "learning_rate": 0.0023390838490718042, + "drop_p": 0.07901326258919673, + "weight_decay": 0.00011169631011445358, + "beta": 0.0012900763592839054, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1863, + "n_layers": 4, + "enc_factor": 1.8080630745560589, + "batch_size": 135, + "learning_rate": 2.7354012266424167e-05, + "drop_p": 0.08527601735802973, + "weight_decay": 0.0015265820197896064, + "beta": 0.004235735575960421, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1407, + "n_layers": 2, + "enc_factor": 2.622777582331689, + "batch_size": 158, + "learning_rate": 3.105517145082846e-05, + "drop_p": 0.7317735958431959, + "weight_decay": 0.07174323581574178, + "beta": 0.03602264582766635, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3256, + "n_layers": 3, + "enc_factor": 1.3910499894765431, + "batch_size": 235, + "learning_rate": 0.03971141402984009, + "drop_p": 0.6880321351466642, + "weight_decay": 0.00012699648551691697, + "beta": 0.001202967062156803, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3868, + "n_layers": 3, + "enc_factor": 2.635698931980449, + "batch_size": 228, + "learning_rate": 0.0005477180258660427, + "drop_p": 0.11657977390822775, + "weight_decay": 0.0004129520710622451, + "beta": 0.00016358900264835583, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 583, + "n_layers": 4, + "enc_factor": 3.8590888094810727, + "batch_size": 140, + "learning_rate": 0.021284644246417614, + "drop_p": 0.010637058670572741, + "weight_decay": 3.467861092067699e-05, + "beta": 0.07404405844006562, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 583, + "n_layers": 3, + "enc_factor": 2.801898179192039, + "batch_size": 204, + "learning_rate": 0.003661035861014162, + "drop_p": 0.646323380681671, + "weight_decay": 0.07244799793797184, + "beta": 0.0005831679683760124, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3187, + "n_layers": 4, + "enc_factor": 3.494390270239742, + "batch_size": 208, + "learning_rate": 0.0035063059262822275, + "drop_p": 0.3002615994693739, + "weight_decay": 0.027050200566707927, + "beta": 0.0012547509379507483, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 280, + "n_layers": 4, + "enc_factor": 1.5132795654511284, + "batch_size": 141, + "learning_rate": 0.05212980014522695, + "drop_p": 0.5086053746848903, + "weight_decay": 0.09545484701497829, + "beta": 0.11315864267461972, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2375, + "n_layers": 3, + "enc_factor": 3.145753342256551, + "batch_size": 140, + "learning_rate": 0.005703346853987108, + "drop_p": 0.564559358702293, + "weight_decay": 0.008315563037704069, + "beta": 0.006364758623975408, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2841, + "n_layers": 3, + "enc_factor": 3.4253621556313893, + "batch_size": 77, + "learning_rate": 1.5699913148252505e-05, + "drop_p": 0.2414721594977731, + "weight_decay": 8.223843662316221e-05, + "beta": 0.15854501630631865, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1450, + "n_layers": 2, + "enc_factor": 2.345868903032433, + "batch_size": 141, + "learning_rate": 1.7238359176198003e-05, + "drop_p": 0.5564100184351931, + "weight_decay": 0.023008399862376475, + "beta": 0.8004503060830821, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3140, + "n_layers": 4, + "enc_factor": 1.840429889626384, + "batch_size": 81, + "learning_rate": 0.0001327957188746297, + "drop_p": 0.17568883893961887, + "weight_decay": 0.0328626064314801, + "beta": 0.062214361644820824, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 906, + "n_layers": 3, + "enc_factor": 1.1522043967684965, + "batch_size": 208, + "learning_rate": 0.016656780939629398, + "drop_p": 0.8450142826309157, + "weight_decay": 0.0027574212539146084, + "beta": 0.0035772003422533875, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3304, + "n_layers": 2, + "enc_factor": 3.255985452152051, + "batch_size": 37, + "learning_rate": 0.008140376437359384, + "drop_p": 0.6347469774523052, + "weight_decay": 0.04568124375320513, + "beta": 0.00530940115266834, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 297, + "n_layers": 3, + "enc_factor": 2.823449347708942, + "batch_size": 61, + "learning_rate": 0.013961525722851087, + "drop_p": 0.23043364776066433, + "weight_decay": 2.1839651461527903e-05, + "beta": 0.00021284732054785465, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 421, + "n_layers": 3, + "enc_factor": 1.8740012275621525, + "batch_size": 204, + "learning_rate": 0.0034749720892621044, + "drop_p": 0.029085722620308986, + "weight_decay": 0.007930174767755893, + "beta": 0.11485615090209435, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2001, + "n_layers": 4, + "enc_factor": 3.795104290572456, + "batch_size": 86, + "learning_rate": 0.0010777335670507622, + "drop_p": 0.7647772328481268, + "weight_decay": 5.605326197320298e-05, + "beta": 0.004317812400090833, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1277, + "n_layers": 3, + "enc_factor": 3.740217069381964, + "batch_size": 114, + "learning_rate": 0.00010717384738445233, + "drop_p": 0.5712980514552038, + "weight_decay": 0.006329786138130882, + "beta": 0.00010252720133631854, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2013, + "n_layers": 3, + "enc_factor": 3.2187580669977587, + "batch_size": 55, + "learning_rate": 0.0007417134684684324, + "drop_p": 0.7645428456907836, + "weight_decay": 1.1181388532186228e-05, + "beta": 0.0024693968244548234, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 394, + "n_layers": 3, + "enc_factor": 1.7181376119709455, + "batch_size": 46, + "learning_rate": 0.002211649366195814, + "drop_p": 0.4783315628584899, + "weight_decay": 0.0005265313709904119, + "beta": 0.09959403574157176, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 611, + "n_layers": 3, + "enc_factor": 2.043996201385668, + "batch_size": 213, + "learning_rate": 0.00045840405910604947, + "drop_p": 0.3076643343520768, + "weight_decay": 0.07513014391267428, + "beta": 0.0032431937061046016, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2043, + "n_layers": 3, + "enc_factor": 1.4850172219984226, + "batch_size": 217, + "learning_rate": 4.3678385374220326e-05, + "drop_p": 0.5926215700009256, + "weight_decay": 0.05612986048811382, + "beta": 0.0043690106082734026, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1118, + "n_layers": 4, + "enc_factor": 3.743535817681134, + "batch_size": 190, + "learning_rate": 0.00028287955128452377, + "drop_p": 0.08079735475295285, + "weight_decay": 1.4702950420602536e-05, + "beta": 0.0018949863312415602, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2470, + "n_layers": 4, + "enc_factor": 3.5020041215343802, + "batch_size": 108, + "learning_rate": 0.05496280562299245, + "drop_p": 0.08992500143321694, + "weight_decay": 2.4362045019067692e-05, + "beta": 0.0012276852607070285, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 471, + "n_layers": 2, + "enc_factor": 1.6767022325967356, + "batch_size": 153, + "learning_rate": 0.0011961540739229993, + "drop_p": 0.6331255359392945, + "weight_decay": 0.07474761710462889, + "beta": 0.00025344187203319416, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 649, + "n_layers": 3, + "enc_factor": 2.912649799148762, + "batch_size": 120, + "learning_rate": 0.025493006075430893, + "drop_p": 0.5475786587319602, + "weight_decay": 6.868349934166501e-05, + "beta": 0.00010422664213410911, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 317, + "n_layers": 4, + "enc_factor": 1.5169446189057898, + "batch_size": 33, + "learning_rate": 5.621333638828131e-05, + "drop_p": 0.43114904659962905, + "weight_decay": 0.025562991473770644, + "beta": 0.019144456164386335, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 265, + "n_layers": 3, + "enc_factor": 3.1969815973038607, + "batch_size": 61, + "learning_rate": 0.001269730023364035, + "drop_p": 0.049897654441208174, + "weight_decay": 0.00033958513629073515, + "beta": 0.006733649164181694, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3274, + "n_layers": 4, + "enc_factor": 1.8501807283927942, + "batch_size": 77, + "learning_rate": 0.04490645157251292, + "drop_p": 0.10908267198522596, + "weight_decay": 0.00017120944297381368, + "beta": 0.04268403014022982, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1433, + "n_layers": 3, + "enc_factor": 3.390760105795554, + "batch_size": 150, + "learning_rate": 0.001629138089292404, + "drop_p": 0.24385032167169798, + "weight_decay": 0.016854391456388826, + "beta": 0.000480747920430712, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1990, + "n_layers": 4, + "enc_factor": 1.294221003856878, + "batch_size": 161, + "learning_rate": 2.6089541685433515e-05, + "drop_p": 0.5799335182294411, + "weight_decay": 0.003294348317082597, + "beta": 0.3810912906774997, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2972, + "n_layers": 2, + "enc_factor": 1.216185806373003, + "batch_size": 126, + "learning_rate": 2.636956098651317e-05, + "drop_p": 0.772058304471086, + "weight_decay": 6.309165575690663e-05, + "beta": 0.0002670183056701514, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 868, + "n_layers": 3, + "enc_factor": 1.6708566640693867, + "batch_size": 124, + "learning_rate": 2.8895694059583715e-05, + "drop_p": 0.2605594207778415, + "weight_decay": 0.04861220804182053, + "beta": 0.12501575564569514, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3644, + "n_layers": 3, + "enc_factor": 3.1843849073648904, + "batch_size": 226, + "learning_rate": 0.04887967241679302, + "drop_p": 0.00486104738869414, + "weight_decay": 0.0011164672464181115, + "beta": 0.6800266848984567, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2451, + "n_layers": 4, + "enc_factor": 3.5765231804978668, + "batch_size": 53, + "learning_rate": 0.0001331962311223091, + "drop_p": 0.01767380545432471, + "weight_decay": 0.00026882771881859093, + "beta": 0.7581928438098733, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 341, + "n_layers": 4, + "enc_factor": 1.236314693862281, + "batch_size": 80, + "learning_rate": 0.0003460862860970779, + "drop_p": 0.6257101580199442, + "weight_decay": 0.006946432406892342, + "beta": 0.13899886073776618, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2413, + "n_layers": 3, + "enc_factor": 2.230651568897925, + "batch_size": 175, + "learning_rate": 0.004654828695148234, + "drop_p": 0.8057675149545173, + "weight_decay": 7.912186153685819e-05, + "beta": 0.5804310815657868, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1491, + "n_layers": 2, + "enc_factor": 1.1317026307369311, + "batch_size": 42, + "learning_rate": 0.0008099765922639631, + "drop_p": 0.5000090428824647, + "weight_decay": 2.7882077526108348e-05, + "beta": 0.0780605222868817, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 129, + "n_layers": 3, + "enc_factor": 2.4673586994074648, + "batch_size": 123, + "learning_rate": 0.07775706870212884, + "drop_p": 0.7825202865067475, + "weight_decay": 0.035111250426298285, + "beta": 0.0006698708574809086, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 949, + "n_layers": 4, + "enc_factor": 2.5498140965738543, + "batch_size": 190, + "learning_rate": 0.003145396889980555, + "drop_p": 0.5022874129774287, + "weight_decay": 0.00018732647165328173, + "beta": 0.1281730861597567, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1111, + "n_layers": 3, + "enc_factor": 3.277830661323879, + "batch_size": 230, + "learning_rate": 5.7879319443130096e-05, + "drop_p": 0.6001210469335326, + "weight_decay": 0.0023766922160032636, + "beta": 0.012805931758243157, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 457, + "n_layers": 3, + "enc_factor": 3.5373298807275515, + "batch_size": 227, + "learning_rate": 0.004430070261484284, + "drop_p": 0.01752844427691578, + "weight_decay": 0.001030580393696442, + "beta": 0.033019797385419304, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1569, + "n_layers": 4, + "enc_factor": 2.472132819327268, + "batch_size": 57, + "learning_rate": 2.1934034850014486e-05, + "drop_p": 0.4368200421198824, + "weight_decay": 1.0365012079748268e-05, + "beta": 0.0012064330743819622, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1116, + "n_layers": 2, + "enc_factor": 1.5503923780839073, + "batch_size": 206, + "learning_rate": 0.04333595829676328, + "drop_p": 0.6871299114543409, + "weight_decay": 0.00038386168998713426, + "beta": 0.1505010258911661, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3737, + "n_layers": 3, + "enc_factor": 3.0059281827647055, + "batch_size": 57, + "learning_rate": 0.0021127520837529662, + "drop_p": 0.5500719509093814, + "weight_decay": 1.3225075191192126e-05, + "beta": 0.016785846406299657, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 232, + "n_layers": 4, + "enc_factor": 2.9842664421673746, + "batch_size": 45, + "learning_rate": 0.028816366316030798, + "drop_p": 0.47412944006163854, + "weight_decay": 2.901856471036759e-05, + "beta": 0.055568013074994635, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 151, + "n_layers": 4, + "enc_factor": 1.3385638055115563, + "batch_size": 249, + "learning_rate": 0.00019039305966723637, + "drop_p": 0.06541850961569645, + "weight_decay": 0.006928421647400142, + "beta": 0.13067834166759074, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2747, + "n_layers": 3, + "enc_factor": 1.90097310966557, + "batch_size": 212, + "learning_rate": 0.004818300128913608, + "drop_p": 0.7849808894133462, + "weight_decay": 0.00031331655342682217, + "beta": 0.0027200240420180003, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2764, + "n_layers": 3, + "enc_factor": 2.377275145141887, + "batch_size": 130, + "learning_rate": 0.004341869066319999, + "drop_p": 0.8386140861679956, + "weight_decay": 0.0015843741423006122, + "beta": 0.4776567231970987, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 256, + "n_layers": 3, + "enc_factor": 1.4715646654967283, + "batch_size": 227, + "learning_rate": 0.034728189703884006, + "drop_p": 0.13697379755466038, + "weight_decay": 0.00022930968234402066, + "beta": 0.5391826826347625, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 533, + "n_layers": 2, + "enc_factor": 2.613641952555152, + "batch_size": 94, + "learning_rate": 1.3939008287527804e-05, + "drop_p": 0.01916897710984481, + "weight_decay": 9.640824023929738e-05, + "beta": 0.01720052683481002, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2435, + "n_layers": 4, + "enc_factor": 2.664923002921423, + "batch_size": 196, + "learning_rate": 0.01678482277346234, + "drop_p": 0.5779481913708465, + "weight_decay": 0.054961154149398686, + "beta": 0.00041488127603318375, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2189, + "n_layers": 4, + "enc_factor": 1.1850469126119667, + "batch_size": 164, + "learning_rate": 0.07422852747561326, + "drop_p": 0.02164282450513616, + "weight_decay": 4.578606747967529e-05, + "beta": 0.0815334617438201, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2604, + "n_layers": 4, + "enc_factor": 1.3274702297269845, + "batch_size": 219, + "learning_rate": 0.023833024584574924, + "drop_p": 0.02795106711828559, + "weight_decay": 0.00027645273699790216, + "beta": 0.08492153696944603, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2012, + "n_layers": 4, + "enc_factor": 2.5242465457866787, + "batch_size": 61, + "learning_rate": 1.284868372930795e-05, + "drop_p": 0.141867026647436, + "weight_decay": 2.0406099499781574e-05, + "beta": 0.05751068208637009, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 949, + "n_layers": 4, + "enc_factor": 2.455098101296564, + "batch_size": 206, + "learning_rate": 5.662449602381089e-05, + "drop_p": 0.11945252664563628, + "weight_decay": 0.00046556967906364574, + "beta": 0.08258814078446149, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 174, + "n_layers": 2, + "enc_factor": 2.870728694180287, + "batch_size": 39, + "learning_rate": 2.8592596373121764e-05, + "drop_p": 0.6015996789141369, + "weight_decay": 0.01283623591991257, + "beta": 0.0006427935342720808, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3816, + "n_layers": 2, + "enc_factor": 2.0848826038498722, + "batch_size": 49, + "learning_rate": 0.00016940805879092679, + "drop_p": 0.542444195472009, + "weight_decay": 9.550674445470784e-05, + "beta": 0.10420651207986854, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 845, + "n_layers": 3, + "enc_factor": 2.035718647489288, + "batch_size": 241, + "learning_rate": 0.05754824644999294, + "drop_p": 0.2875245061560504, + "weight_decay": 0.00278071140778743, + "beta": 0.018325632067870756, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1859, + "n_layers": 3, + "enc_factor": 3.4886949235260665, + "batch_size": 202, + "learning_rate": 0.0002813469772216988, + "drop_p": 0.03707264638167005, + "weight_decay": 0.000479090207272262, + "beta": 0.003034294259668654, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 154, + "n_layers": 3, + "enc_factor": 1.6107321687027103, + "batch_size": 211, + "learning_rate": 3.8870104908250515e-05, + "drop_p": 0.43552931622633634, + "weight_decay": 4.812925742540987e-05, + "beta": 0.0003111817007998546, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1405, + "n_layers": 3, + "enc_factor": 1.4374962859558489, + "batch_size": 68, + "learning_rate": 0.0029194533070222685, + "drop_p": 0.2980620384769368, + "weight_decay": 0.0005502317233227108, + "beta": 0.002958691276281605, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1663, + "n_layers": 4, + "enc_factor": 1.8063408575256203, + "batch_size": 121, + "learning_rate": 0.00014061161276496376, + "drop_p": 0.832206574539881, + "weight_decay": 0.008400773583377765, + "beta": 0.2834075823679323, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 883, + "n_layers": 3, + "enc_factor": 2.004882607069713, + "batch_size": 186, + "learning_rate": 0.06436746532036823, + "drop_p": 0.21925667971031548, + "weight_decay": 1.130014236226146e-05, + "beta": 0.0010520099998685736, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1919, + "n_layers": 3, + "enc_factor": 3.892053066271396, + "batch_size": 107, + "learning_rate": 0.0877911512054139, + "drop_p": 0.7025337217217983, + "weight_decay": 3.521596831319192e-05, + "beta": 0.0005613341125802813, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 434, + "n_layers": 2, + "enc_factor": 1.0052585412945374, + "batch_size": 198, + "learning_rate": 7.795828856708996e-05, + "drop_p": 0.2633408927295091, + "weight_decay": 9.416464985856667e-05, + "beta": 0.00028708522784045117, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1500, + "n_layers": 3, + "enc_factor": 3.357867951555937, + "batch_size": 186, + "learning_rate": 0.0021056339549768138, + "drop_p": 0.5997311014530644, + "weight_decay": 0.0005460842118941284, + "beta": 0.11376302287088327, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 208, + "n_layers": 3, + "enc_factor": 3.990543218103427, + "batch_size": 66, + "learning_rate": 0.003956729144204563, + "drop_p": 0.2261916958391815, + "weight_decay": 0.00024480413459883685, + "beta": 0.0002565628811977902, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 338, + "n_layers": 3, + "enc_factor": 1.0117614311738352, + "batch_size": 222, + "learning_rate": 7.940141222640902e-05, + "drop_p": 0.37056251356693676, + "weight_decay": 0.001101529526366238, + "beta": 0.019807958764382357, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3735, + "n_layers": 2, + "enc_factor": 1.033646839996228, + "batch_size": 189, + "learning_rate": 0.00010106094732091855, + "drop_p": 0.11621896635890508, + "weight_decay": 0.017848345654348712, + "beta": 0.0017930544755314015, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1146, + "n_layers": 3, + "enc_factor": 1.9580521029167732, + "batch_size": 88, + "learning_rate": 2.7958856081073376e-05, + "drop_p": 0.3633963730780597, + "weight_decay": 0.0203378990835126, + "beta": 0.0015120204201537273, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2531, + "n_layers": 3, + "enc_factor": 3.25330920401067, + "batch_size": 138, + "learning_rate": 0.08638735317647556, + "drop_p": 0.6466804156108192, + "weight_decay": 0.003061471380845914, + "beta": 0.0019903368178991955, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 4081, + "n_layers": 3, + "enc_factor": 2.147696653053017, + "batch_size": 59, + "learning_rate": 1.204627367340457e-05, + "drop_p": 0.20919689892855917, + "weight_decay": 0.020191856556209864, + "beta": 0.00010132162049443838, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 163, + "n_layers": 4, + "enc_factor": 2.6895132669875266, + "batch_size": 231, + "learning_rate": 0.0001917110360378409, + "drop_p": 0.48305707583347984, + "weight_decay": 0.000679315714208893, + "beta": 0.0571650191613924, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2232, + "n_layers": 2, + "enc_factor": 2.6352594916634287, + "batch_size": 137, + "learning_rate": 0.0025246529438153966, + "drop_p": 0.6734396106189522, + "weight_decay": 0.0007618970005721424, + "beta": 0.000988364077672838, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + }, + "schc": { + "downstream": [ + { + "k_filter": 715, + "n_layers": 3, + "enc_factor": 1.5696476106753807, + "batch_size": 181, + "learning_rate": 0.0001161275247828524, + "drop_p": 0.38057595572778685, + "weight_decay": 2.6148708359111213e-05, + "beta": 0.00013241293984231944, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 919, + "n_layers": 2, + "enc_factor": 3.9430480896291167, + "batch_size": 162, + "learning_rate": 0.013731776050776726, + "drop_p": 0.7004758368247445, + "weight_decay": 0.0004294920393663528, + "beta": 0.016396458859983355, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1398, + "n_layers": 4, + "enc_factor": 1.936258871685686, + "batch_size": 43, + "learning_rate": 0.001081435290016514, + "drop_p": 0.5452230426503782, + "weight_decay": 0.01954734609510236, + "beta": 0.006165191184198054, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2087, + "n_layers": 3, + "enc_factor": 3.8585821219228205, + "batch_size": 212, + "learning_rate": 5.903486598554149e-05, + "drop_p": 0.2929078307810656, + "weight_decay": 0.0015080242370348106, + "beta": 0.00016095456491171386, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3265, + "n_layers": 3, + "enc_factor": 1.6036823758759717, + "batch_size": 160, + "learning_rate": 0.010445080903897976, + "drop_p": 0.19059806978612373, + "weight_decay": 0.046184956969860635, + "beta": 0.0004924271237031369, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3019, + "n_layers": 2, + "enc_factor": 2.439597993939436, + "batch_size": 135, + "learning_rate": 9.318699433932946e-05, + "drop_p": 0.2757846460514533, + "weight_decay": 1.7664540383332427e-05, + "beta": 0.003849967843339462, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1875, + "n_layers": 3, + "enc_factor": 2.9074797623039363, + "batch_size": 238, + "learning_rate": 0.0010217883431494496, + "drop_p": 0.5496419483777276, + "weight_decay": 0.03385561541388282, + "beta": 0.0011033892037963888, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3383, + "n_layers": 4, + "enc_factor": 3.006487615743522, + "batch_size": 63, + "learning_rate": 0.0006173997858217317, + "drop_p": 0.16308057966284675, + "weight_decay": 6.120678453333026e-05, + "beta": 0.000976973845775981, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3280, + "n_layers": 3, + "enc_factor": 2.210575368011422, + "batch_size": 184, + "learning_rate": 3.476028055568167e-05, + "drop_p": 0.09885939909888171, + "weight_decay": 0.011114827719413963, + "beta": 0.3967127372748283, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1851, + "n_layers": 2, + "enc_factor": 1.8395748405690588, + "batch_size": 59, + "learning_rate": 0.00014321831244059046, + "drop_p": 0.1799865504097033, + "weight_decay": 0.0004643248637129821, + "beta": 0.0002686163748688181, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 1184, + "n_layers": 3, + "enc_factor": 2.5148124018362195, + "batch_size": 162, + "learning_rate": 0.0009570033269666977, + "drop_p": 0.5925110226784664, + "weight_decay": 0.0008941385263982435, + "beta": 0.00027327121439731756, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 175, + "n_layers": 2, + "enc_factor": 3.681013397506511, + "batch_size": 220, + "learning_rate": 0.001171895062990904, + "drop_p": 0.5932878230772576, + "weight_decay": 0.003986744736875573, + "beta": 0.008231568520489395, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 199, + "n_layers": 3, + "enc_factor": 1.2036161853807519, + "batch_size": 151, + "learning_rate": 0.0016865179225211341, + "drop_p": 0.04643597038880476, + "weight_decay": 0.0566760667702681, + "beta": 0.006566410915345536, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2726, + "n_layers": 4, + "enc_factor": 2.862359706178953, + "batch_size": 175, + "learning_rate": 0.0011288456991636062, + "drop_p": 0.4184828329817152, + "weight_decay": 0.02538895460674115, + "beta": 0.9852246368577027, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1956, + "n_layers": 3, + "enc_factor": 2.2084249025644556, + "batch_size": 156, + "learning_rate": 0.01310938107222295, + "drop_p": 0.3637616503295708, + "weight_decay": 0.0017566020827942488, + "beta": 0.0001444802676742137, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1115, + "n_layers": 3, + "enc_factor": 2.9146234689478305, + "batch_size": 58, + "learning_rate": 8.339694701297809e-05, + "drop_p": 0.7604427391166865, + "weight_decay": 0.0031473433605781784, + "beta": 0.007234882856184795, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1598, + "n_layers": 4, + "enc_factor": 2.0330224040871037, + "batch_size": 115, + "learning_rate": 1.5296384657129795e-05, + "drop_p": 0.24086572585399013, + "weight_decay": 2.248377871543091e-05, + "beta": 0.0001415344751876562, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 234, + "n_layers": 3, + "enc_factor": 3.3627576926744935, + "batch_size": 167, + "learning_rate": 0.08046595582716948, + "drop_p": 0.46578823855062096, + "weight_decay": 0.023829030383601214, + "beta": 0.0001772157640283973, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2636, + "n_layers": 3, + "enc_factor": 2.5549236567708835, + "batch_size": 96, + "learning_rate": 0.00106558153726295, + "drop_p": 0.43172536623829516, + "weight_decay": 2.754698487248055e-05, + "beta": 0.10893275379967242, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 253, + "n_layers": 3, + "enc_factor": 2.000364609251979, + "batch_size": 107, + "learning_rate": 0.027746859702085853, + "drop_p": 0.45424339357816157, + "weight_decay": 4.3687492780803166e-05, + "beta": 0.3757338089117668, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 762, + "n_layers": 4, + "enc_factor": 2.789991473603054, + "batch_size": 33, + "learning_rate": 0.08681366982133773, + "drop_p": 0.18900364820208979, + "weight_decay": 0.00587826201424082, + "beta": 0.0015283076620146855, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 154, + "n_layers": 2, + "enc_factor": 2.100574192557681, + "batch_size": 179, + "learning_rate": 0.0011417247372827125, + "drop_p": 0.33233017708280366, + "weight_decay": 8.62798554582802e-05, + "beta": 0.04499072103736301, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2014, + "n_layers": 2, + "enc_factor": 3.8474073582529993, + "batch_size": 245, + "learning_rate": 0.0017347503431931147, + "drop_p": 0.6531267462098017, + "weight_decay": 0.085623734379694, + "beta": 0.003423750653542872, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1444, + "n_layers": 4, + "enc_factor": 2.145420037300951, + "batch_size": 205, + "learning_rate": 6.126529256417664e-05, + "drop_p": 0.1728408707667841, + "weight_decay": 0.01222844650898715, + "beta": 0.00010194228858590288, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3682, + "n_layers": 2, + "enc_factor": 2.1827437986316673, + "batch_size": 80, + "learning_rate": 0.003944626477280199, + "drop_p": 0.13775989526662716, + "weight_decay": 0.019797660828779023, + "beta": 0.28835983682525407, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1360, + "n_layers": 4, + "enc_factor": 1.4813438299379795, + "batch_size": 234, + "learning_rate": 0.0066739636714626075, + "drop_p": 0.20504973534000878, + "weight_decay": 0.004907146485745582, + "beta": 0.010920951244709872, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 281, + "n_layers": 3, + "enc_factor": 3.38425132625561, + "batch_size": 105, + "learning_rate": 0.09430504517011498, + "drop_p": 0.3095650614544309, + "weight_decay": 0.0024481230056417357, + "beta": 0.0068914941515242105, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2997, + "n_layers": 3, + "enc_factor": 3.1204741598473937, + "batch_size": 64, + "learning_rate": 0.0010484077817744283, + "drop_p": 0.45097501386876215, + "weight_decay": 0.00042358094467975137, + "beta": 0.3637354641401246, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2024, + "n_layers": 2, + "enc_factor": 3.347085202585537, + "batch_size": 212, + "learning_rate": 0.004412608602982376, + "drop_p": 0.08693006294997568, + "weight_decay": 0.06610570003771132, + "beta": 0.010723149966471683, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 307, + "n_layers": 3, + "enc_factor": 2.5447719325708573, + "batch_size": 227, + "learning_rate": 0.00011955177515024855, + "drop_p": 0.8193028968553159, + "weight_decay": 0.0002060000238347586, + "beta": 0.01390483906265474, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 1837, + "n_layers": 3, + "enc_factor": 1.9390901806159282, + "batch_size": 98, + "learning_rate": 0.0012748920039420337, + "drop_p": 0.605319282119433, + "weight_decay": 0.0001732538708728875, + "beta": 0.0008334127397612014, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3928, + "n_layers": 4, + "enc_factor": 3.283684653690152, + "batch_size": 113, + "learning_rate": 0.09778269144219066, + "drop_p": 0.5030963691229448, + "weight_decay": 0.025617879794204063, + "beta": 0.010153510619209653, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 592, + "n_layers": 2, + "enc_factor": 1.05740335202567, + "batch_size": 77, + "learning_rate": 0.006166222343932389, + "drop_p": 0.8469328366425378, + "weight_decay": 0.03069193742692128, + "beta": 0.0006400431702402172, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1028, + "n_layers": 3, + "enc_factor": 2.282470003317071, + "batch_size": 160, + "learning_rate": 0.08752743836263552, + "drop_p": 0.3712165519156913, + "weight_decay": 0.00010744894020026472, + "beta": 0.0003794008242655917, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 399, + "n_layers": 3, + "enc_factor": 2.9168150645371735, + "batch_size": 79, + "learning_rate": 0.033484022510009204, + "drop_p": 0.40137671414839055, + "weight_decay": 0.0025839083048546296, + "beta": 0.004469215693263915, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3011, + "n_layers": 3, + "enc_factor": 3.449439132169904, + "batch_size": 134, + "learning_rate": 0.005978125837788468, + "drop_p": 0.09301057041317831, + "weight_decay": 5.333429042675778e-05, + "beta": 0.0001958198310386538, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3751, + "n_layers": 4, + "enc_factor": 1.200041774422389, + "batch_size": 108, + "learning_rate": 0.00013544030653389418, + "drop_p": 0.6196219029162555, + "weight_decay": 0.002505885840083267, + "beta": 0.001341773111433244, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3185, + "n_layers": 2, + "enc_factor": 3.109260435143974, + "batch_size": 51, + "learning_rate": 0.02399583808698022, + "drop_p": 0.4289039253133913, + "weight_decay": 1.1325776755725715e-05, + "beta": 0.009116103302232823, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3311, + "n_layers": 3, + "enc_factor": 2.910511510845088, + "batch_size": 196, + "learning_rate": 0.01322916409257736, + "drop_p": 0.5558086890348795, + "weight_decay": 0.06074672279179708, + "beta": 0.02312302192262449, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 182, + "n_layers": 3, + "enc_factor": 1.8924453836823507, + "batch_size": 37, + "learning_rate": 0.0004850009726317229, + "drop_p": 0.03062212729221564, + "weight_decay": 8.71455422194405e-05, + "beta": 0.2535193344674184, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 453, + "n_layers": 3, + "enc_factor": 3.7675448335469865, + "batch_size": 183, + "learning_rate": 0.00032831047708689127, + "drop_p": 0.32617211879736846, + "weight_decay": 1.5480331231039867e-05, + "beta": 0.00027656498765024645, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 4089, + "n_layers": 3, + "enc_factor": 1.2761300615447868, + "batch_size": 212, + "learning_rate": 0.031570260373085364, + "drop_p": 0.3401500357355276, + "weight_decay": 0.09902824637729586, + "beta": 0.14560812277895124, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1342, + "n_layers": 3, + "enc_factor": 3.5114413868042305, + "batch_size": 96, + "learning_rate": 0.004388408672409009, + "drop_p": 0.20466312159164682, + "weight_decay": 0.0033822231458867378, + "beta": 0.003893351962309708, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 250, + "n_layers": 2, + "enc_factor": 1.1293880030145313, + "batch_size": 124, + "learning_rate": 0.024416345598188127, + "drop_p": 0.7609071763421339, + "weight_decay": 0.001401344131766845, + "beta": 0.12944653933168812, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 4094, + "n_layers": 3, + "enc_factor": 1.675045258953761, + "batch_size": 167, + "learning_rate": 0.015248733561288865, + "drop_p": 0.15111501077610828, + "weight_decay": 0.004378187872630647, + "beta": 0.06273168877127515, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3872, + "n_layers": 3, + "enc_factor": 1.0969838990917926, + "batch_size": 170, + "learning_rate": 2.3167357149471103e-05, + "drop_p": 0.12655113657591102, + "weight_decay": 0.0021632662693190294, + "beta": 0.012102409615880995, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3526, + "n_layers": 4, + "enc_factor": 1.75003941541424, + "batch_size": 223, + "learning_rate": 0.00028116972124280485, + "drop_p": 0.2841857342605447, + "weight_decay": 0.004259752441222722, + "beta": 0.0031088597959632964, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 861, + "n_layers": 3, + "enc_factor": 1.0761573079566622, + "batch_size": 75, + "learning_rate": 0.0031564570097835144, + "drop_p": 0.6306339747691326, + "weight_decay": 0.052542624577935446, + "beta": 0.003597857887384621, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1135, + "n_layers": 3, + "enc_factor": 1.8571456340393195, + "batch_size": 146, + "learning_rate": 0.08178115235707717, + "drop_p": 0.19109810672963065, + "weight_decay": 4.706511508454829e-05, + "beta": 0.06246450769446858, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 296, + "n_layers": 3, + "enc_factor": 2.4367427575325555, + "batch_size": 42, + "learning_rate": 0.09036825888499507, + "drop_p": 0.31262772435103947, + "weight_decay": 0.0015071647079434112, + "beta": 0.0005395884239389726, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 145, + "n_layers": 3, + "enc_factor": 3.4570690515324456, + "batch_size": 66, + "learning_rate": 0.002491225984212496, + "drop_p": 0.2941827637876821, + "weight_decay": 0.02337484307253178, + "beta": 0.12826245225282837, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2114, + "n_layers": 2, + "enc_factor": 1.856819928229004, + "batch_size": 72, + "learning_rate": 0.0001465350901413059, + "drop_p": 0.8669864592187406, + "weight_decay": 0.009646298935435463, + "beta": 0.00010464375747982845, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1154, + "n_layers": 2, + "enc_factor": 3.4575966490645023, + "batch_size": 238, + "learning_rate": 0.05843304062205553, + "drop_p": 0.289769958498199, + "weight_decay": 0.007311041891526724, + "beta": 0.00017941199600771278, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1585, + "n_layers": 2, + "enc_factor": 1.2084687871689401, + "batch_size": 94, + "learning_rate": 0.00011579534728149143, + "drop_p": 0.7042295599399789, + "weight_decay": 0.004590425068668047, + "beta": 0.00021541166613049876, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 252, + "n_layers": 3, + "enc_factor": 1.5514938737999253, + "batch_size": 54, + "learning_rate": 0.0009474165835230768, + "drop_p": 0.26056912903169055, + "weight_decay": 0.01237535799422706, + "beta": 0.0009362361796764254, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2199, + "n_layers": 4, + "enc_factor": 2.834604429423559, + "batch_size": 121, + "learning_rate": 7.033302882795571e-05, + "drop_p": 0.6724384476317627, + "weight_decay": 0.004693921287562504, + "beta": 0.0007305674342797025, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 296, + "n_layers": 4, + "enc_factor": 2.640804164815064, + "batch_size": 165, + "learning_rate": 4.8494883590859354e-05, + "drop_p": 0.5516754026634024, + "weight_decay": 0.00033899203835414656, + "beta": 0.667299998212901, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 597, + "n_layers": 4, + "enc_factor": 2.76952088282452, + "batch_size": 93, + "learning_rate": 0.0008585340702621256, + "drop_p": 0.17902315754722392, + "weight_decay": 9.743565601136497e-05, + "beta": 0.0631976073507152, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2583, + "n_layers": 3, + "enc_factor": 2.0457942275086367, + "batch_size": 211, + "learning_rate": 0.09274554868241879, + "drop_p": 0.755685618878715, + "weight_decay": 1.8373492569251332e-05, + "beta": 0.002196090988692642, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1461, + "n_layers": 2, + "enc_factor": 1.1135884982938404, + "batch_size": 64, + "learning_rate": 0.0006002863462560012, + "drop_p": 0.07060722630193332, + "weight_decay": 0.005781225763370533, + "beta": 0.005086571172117475, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 1800, + "n_layers": 2, + "enc_factor": 3.153183835251272, + "batch_size": 151, + "learning_rate": 0.05357190262474288, + "drop_p": 0.034851204265087546, + "weight_decay": 0.009248913207116516, + "beta": 0.0007348970650998687, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 458, + "n_layers": 2, + "enc_factor": 3.061965865484117, + "batch_size": 176, + "learning_rate": 1.644827657703285e-05, + "drop_p": 0.24766237226048451, + "weight_decay": 7.437053766297276e-05, + "beta": 0.00017791468539718263, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3228, + "n_layers": 3, + "enc_factor": 1.089919430082169, + "batch_size": 103, + "learning_rate": 0.004159633968503051, + "drop_p": 0.6690522077527657, + "weight_decay": 0.016875575808257652, + "beta": 0.004017680189170094, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3057, + "n_layers": 2, + "enc_factor": 3.953856996176316, + "batch_size": 55, + "learning_rate": 0.011446502960224193, + "drop_p": 0.19065916795979862, + "weight_decay": 4.131299564418202e-05, + "beta": 0.06380921467386212, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1032, + "n_layers": 3, + "enc_factor": 2.054274508094027, + "batch_size": 42, + "learning_rate": 1.8966036311805665e-05, + "drop_p": 0.16551477370284487, + "weight_decay": 0.0001800680783356394, + "beta": 0.008066675670907008, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 589, + "n_layers": 3, + "enc_factor": 1.374617424744152, + "batch_size": 78, + "learning_rate": 3.2162748879179346e-05, + "drop_p": 0.5963267604918382, + "weight_decay": 0.0353936515507795, + "beta": 0.4669522037502441, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 407, + "n_layers": 3, + "enc_factor": 1.6671797330444247, + "batch_size": 241, + "learning_rate": 0.05713292621359808, + "drop_p": 0.8962456454088015, + "weight_decay": 0.00016011862189804874, + "beta": 0.0042280693063711326, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3851, + "n_layers": 4, + "enc_factor": 1.0326878103541932, + "batch_size": 178, + "learning_rate": 0.0003592206809131628, + "drop_p": 0.364405036145893, + "weight_decay": 0.00033664930980786524, + "beta": 0.5174873883273093, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2222, + "n_layers": 3, + "enc_factor": 1.961586058613983, + "batch_size": 110, + "learning_rate": 0.00014527787293168283, + "drop_p": 0.41351993822118477, + "weight_decay": 0.00872335764561764, + "beta": 0.0001494416342492521, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1711, + "n_layers": 3, + "enc_factor": 1.463030629107049, + "batch_size": 113, + "learning_rate": 2.0224231514919e-05, + "drop_p": 0.06339855313324258, + "weight_decay": 0.004993856433076984, + "beta": 0.02200201563384759, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 176, + "n_layers": 4, + "enc_factor": 1.8286668297816147, + "batch_size": 144, + "learning_rate": 3.653109245450088e-05, + "drop_p": 0.75049991599539, + "weight_decay": 0.0011717274982637, + "beta": 0.11969201269851533, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2930, + "n_layers": 3, + "enc_factor": 1.7932372779923464, + "batch_size": 106, + "learning_rate": 4.4221985166351345e-05, + "drop_p": 0.7621895110178499, + "weight_decay": 0.00011257993725690764, + "beta": 0.0005460947526131171, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 138, + "n_layers": 4, + "enc_factor": 1.1829984559606284, + "batch_size": 153, + "learning_rate": 0.06930228621710889, + "drop_p": 0.2481820341846451, + "weight_decay": 0.0005967624585125902, + "beta": 0.009074680843145175, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3024, + "n_layers": 4, + "enc_factor": 1.6305485672053226, + "batch_size": 125, + "learning_rate": 0.00024348384748045987, + "drop_p": 0.7515526783122184, + "weight_decay": 0.0005310188226051125, + "beta": 0.00045863260196886706, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1328, + "n_layers": 2, + "enc_factor": 3.2905669057035416, + "batch_size": 125, + "learning_rate": 1.5062371382602305e-05, + "drop_p": 0.0723472202047204, + "weight_decay": 0.0002589773404640107, + "beta": 0.005113161452553713, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2115, + "n_layers": 3, + "enc_factor": 3.04942769486813, + "batch_size": 189, + "learning_rate": 0.02079576478726367, + "drop_p": 0.6472152268703493, + "weight_decay": 3.23668769396744e-05, + "beta": 0.024215866323846924, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1803, + "n_layers": 4, + "enc_factor": 3.9917220921719028, + "batch_size": 75, + "learning_rate": 1.1542729245699926e-05, + "drop_p": 0.2088392191076142, + "weight_decay": 0.022150006028670427, + "beta": 0.5129138902269361, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1171, + "n_layers": 3, + "enc_factor": 2.9959110013460393, + "batch_size": 70, + "learning_rate": 0.056057247367830514, + "drop_p": 0.0030879841273206755, + "weight_decay": 0.0033110442215109415, + "beta": 0.03598160511458734, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 243, + "n_layers": 3, + "enc_factor": 3.489997988623431, + "batch_size": 111, + "learning_rate": 0.05210730246882575, + "drop_p": 0.3048541208736649, + "weight_decay": 1.5004933182008406e-05, + "beta": 0.945035865512089, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2989, + "n_layers": 3, + "enc_factor": 1.259551640909459, + "batch_size": 161, + "learning_rate": 0.028116542065194348, + "drop_p": 0.07706783103332585, + "weight_decay": 0.00271176544627828, + "beta": 0.24217981094400978, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + } + }, + "disentanglix": { + "combined": { + "downstream": [ + { + "k_filter": 3192, + "n_layers": 2, + "enc_factor": 3.88332155671601, + "batch_size": 186, + "learning_rate": 0.00012949239958984175, + "drop_p": 0.18741964730681546, + "weight_decay": 0.0002923635082606169, + "latent_dim": 22, + "beta_mi": 0.023456411077333372, + "beta_tc": 117.11080051498587, + "beta_dimKL": 0.7039391575861601, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 4055, + "n_layers": 2, + "enc_factor": 3.828894424647467, + "batch_size": 173, + "learning_rate": 4.258646912865924e-05, + "drop_p": 0.16984204243939358, + "weight_decay": 0.055355421942011054, + "latent_dim": 51, + "beta_mi": 0.0022183570659502347, + "beta_tc": 4.248479965792164, + "beta_dimKL": 0.007275279294159567, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2823, + "n_layers": 3, + "enc_factor": 3.818923050432615, + "batch_size": 242, + "learning_rate": 0.051945431376634335, + "drop_p": 0.725116338004754, + "weight_decay": 0.0003811631184173441, + "latent_dim": 49, + "beta_mi": 0.012563401802247895, + "beta_tc": 1.391401331243942, + "beta_dimKL": 1.3852027671719542, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2107, + "n_layers": 4, + "enc_factor": 3.588106605518748, + "batch_size": 211, + "learning_rate": 0.003001443198362281, + "drop_p": 0.23242789768218508, + "weight_decay": 0.00019864271095266757, + "latent_dim": 63, + "beta_mi": 0.07565793671811655, + "beta_tc": 0.8185226027869734, + "beta_dimKL": 0.0035168608015791443, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2899, + "n_layers": 4, + "enc_factor": 2.2909765056825755, + "batch_size": 205, + "learning_rate": 0.023120053016820127, + "drop_p": 0.6882126200931863, + "weight_decay": 0.00027474827774143603, + "latent_dim": 40, + "beta_mi": 0.2293222237119515, + "beta_tc": 0.35629052930698135, + "beta_dimKL": 0.499158639921584, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 647, + "n_layers": 3, + "enc_factor": 2.68189463623548, + "batch_size": 126, + "learning_rate": 2.4865532395046997e-05, + "drop_p": 0.09587969748774139, + "weight_decay": 0.006932678493408638, + "latent_dim": 55, + "beta_mi": 0.31594091269858837, + "beta_tc": 1.426464059252313, + "beta_dimKL": 0.02009379115088745, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3874, + "n_layers": 3, + "enc_factor": 2.885384078234832, + "batch_size": 206, + "learning_rate": 6.086502258672312e-05, + "drop_p": 0.17526456514473124, + "weight_decay": 0.017947368652480797, + "latent_dim": 47, + "beta_mi": 0.002642268255017888, + "beta_tc": 0.25969467723708634, + "beta_dimKL": 0.002227568886522621, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2840, + "n_layers": 3, + "enc_factor": 1.0146273800411603, + "batch_size": 226, + "learning_rate": 6.881355267299457e-05, + "drop_p": 0.3406765685654263, + "weight_decay": 0.025270852452162533, + "latent_dim": 15, + "beta_mi": 5.263096180760631, + "beta_tc": 128.0529293105019, + "beta_dimKL": 4.830626569199597, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3195, + "n_layers": 3, + "enc_factor": 2.4922347327628622, + "batch_size": 107, + "learning_rate": 9.251547226642531e-05, + "drop_p": 0.059491345268697086, + "weight_decay": 0.0012641290471407168, + "latent_dim": 24, + "beta_mi": 4.431352245736814, + "beta_tc": 2.688497862276139, + "beta_dimKL": 4.936169622514192, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2423, + "n_layers": 3, + "enc_factor": 2.7917330633230115, + "batch_size": 78, + "learning_rate": 8.580058552053887e-05, + "drop_p": 0.366155382792326, + "weight_decay": 0.06640641898796452, + "latent_dim": 32, + "beta_mi": 0.013349523073327239, + "beta_tc": 107.48170689508096, + "beta_dimKL": 0.16657640627620085, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 368, + "n_layers": 3, + "enc_factor": 3.5363666107754126, + "batch_size": 53, + "learning_rate": 0.0010383657999402426, + "drop_p": 0.8364311226677544, + "weight_decay": 5.791386759490452e-05, + "latent_dim": 63, + "beta_mi": 0.0012458548232454978, + "beta_tc": 805.5061262238011, + "beta_dimKL": 0.036673680283568315, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2345, + "n_layers": 4, + "enc_factor": 3.1100716842505713, + "batch_size": 95, + "learning_rate": 0.0269244031551083, + "drop_p": 0.8719814594697104, + "weight_decay": 0.00040500607878142574, + "latent_dim": 46, + "beta_mi": 0.6352496825005928, + "beta_tc": 0.9017900403565431, + "beta_dimKL": 0.24698238305459358, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 202, + "n_layers": 3, + "enc_factor": 1.810429418702995, + "batch_size": 241, + "learning_rate": 7.982821342365777e-05, + "drop_p": 0.3702702838825881, + "weight_decay": 0.013040704465285166, + "latent_dim": 38, + "beta_mi": 3.6199138653983747, + "beta_tc": 333.6102336157224, + "beta_dimKL": 0.4189348952353784, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2176, + "n_layers": 2, + "enc_factor": 2.1250251310764883, + "batch_size": 218, + "learning_rate": 0.014132033585270019, + "drop_p": 0.7308499268988313, + "weight_decay": 1.4833679269937446e-05, + "latent_dim": 7, + "beta_mi": 0.02458777935192392, + "beta_tc": 75.972779675057, + "beta_dimKL": 0.02612816150636331, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 243, + "n_layers": 4, + "enc_factor": 3.097868214174933, + "batch_size": 219, + "learning_rate": 0.0003995504276387935, + "drop_p": 0.4078423994478406, + "weight_decay": 0.00771284319197941, + "latent_dim": 25, + "beta_mi": 2.2486007135680777, + "beta_tc": 1.9334665344837862, + "beta_dimKL": 0.3774654951890217, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2706, + "n_layers": 3, + "enc_factor": 2.929700264170496, + "batch_size": 210, + "learning_rate": 4.947363838447588e-05, + "drop_p": 0.021231812025648524, + "weight_decay": 0.0012777228062958845, + "latent_dim": 8, + "beta_mi": 0.002192778650333656, + "beta_tc": 4.88487635697652, + "beta_dimKL": 0.08160252886790453, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 184, + "n_layers": 2, + "enc_factor": 2.621989502133279, + "batch_size": 56, + "learning_rate": 0.006486836977360069, + "drop_p": 0.1292940032216163, + "weight_decay": 0.016743426707170644, + "latent_dim": 56, + "beta_mi": 7.91238000136615, + "beta_tc": 0.10422340394687395, + "beta_dimKL": 4.333353289503726, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3214, + "n_layers": 2, + "enc_factor": 1.3519262559507799, + "batch_size": 135, + "learning_rate": 0.07612464099722047, + "drop_p": 0.33198028951841857, + "weight_decay": 5.205958761540068e-05, + "latent_dim": 64, + "beta_mi": 0.023250107326346223, + "beta_tc": 54.387632267224696, + "beta_dimKL": 0.14635978071584405, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1763, + "n_layers": 3, + "enc_factor": 1.726608394966033, + "batch_size": 216, + "learning_rate": 0.0002323333173689157, + "drop_p": 0.3953818274438819, + "weight_decay": 0.00010871692750067267, + "latent_dim": 50, + "beta_mi": 4.002454486608282, + "beta_tc": 64.33554483724647, + "beta_dimKL": 0.47667474575376734, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1514, + "n_layers": 3, + "enc_factor": 3.5175812689075263, + "batch_size": 206, + "learning_rate": 0.0006788671555984431, + "drop_p": 0.06316721288525927, + "weight_decay": 1.668915039686657e-05, + "latent_dim": 26, + "beta_mi": 0.5008444207827872, + "beta_tc": 942.8136013345992, + "beta_dimKL": 0.06988001060513079, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 180, + "n_layers": 3, + "enc_factor": 2.1502157759895026, + "batch_size": 169, + "learning_rate": 0.0009420814910908065, + "drop_p": 0.021233369803992343, + "weight_decay": 0.04711930977302881, + "latent_dim": 22, + "beta_mi": 0.1695307236954581, + "beta_tc": 162.118090397728, + "beta_dimKL": 0.0019357182173826855, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 2995, + "n_layers": 3, + "enc_factor": 3.9358924258618297, + "batch_size": 98, + "learning_rate": 0.0004458343240229213, + "drop_p": 0.4273063019367642, + "weight_decay": 5.401698827292861e-05, + "latent_dim": 14, + "beta_mi": 0.006415744234613885, + "beta_tc": 782.7779154992222, + "beta_dimKL": 0.9563246851707999, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3844, + "n_layers": 3, + "enc_factor": 2.935913851172693, + "batch_size": 115, + "learning_rate": 0.021477759544299074, + "drop_p": 0.7563134754309244, + "weight_decay": 0.0001596339062020317, + "latent_dim": 42, + "beta_mi": 2.510054014459692, + "beta_tc": 8006.563825778907, + "beta_dimKL": 0.0035854805449822293, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1260, + "n_layers": 4, + "enc_factor": 1.1369295509051185, + "batch_size": 239, + "learning_rate": 0.05472876078733163, + "drop_p": 0.374688260933051, + "weight_decay": 0.00010700580026462088, + "latent_dim": 42, + "beta_mi": 0.9307894795942265, + "beta_tc": 1800.2117034331957, + "beta_dimKL": 3.549460474178658, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1587, + "n_layers": 2, + "enc_factor": 1.1407776352437622, + "batch_size": 38, + "learning_rate": 0.020906388553717167, + "drop_p": 0.509614334413051, + "weight_decay": 1.7570112434929175e-05, + "latent_dim": 33, + "beta_mi": 2.7372831092310603, + "beta_tc": 3960.381993702558, + "beta_dimKL": 0.0021415252440342225, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 974, + "n_layers": 3, + "enc_factor": 3.9516502396362307, + "batch_size": 195, + "learning_rate": 1.931876525166471e-05, + "drop_p": 0.4906117407559378, + "weight_decay": 0.0009066363419911878, + "latent_dim": 34, + "beta_mi": 1.10717087428284, + "beta_tc": 181.69844630211827, + "beta_dimKL": 1.0258540384690138, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1050, + "n_layers": 2, + "enc_factor": 3.4088360324823066, + "batch_size": 112, + "learning_rate": 4.109532516576462e-05, + "drop_p": 0.5982066721127356, + "weight_decay": 0.0018018260063962903, + "latent_dim": 14, + "beta_mi": 0.013840058954228369, + "beta_tc": 1171.066232984294, + "beta_dimKL": 0.10736671014765412, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3765, + "n_layers": 2, + "enc_factor": 3.447583044682711, + "batch_size": 234, + "learning_rate": 0.032919956961983306, + "drop_p": 0.2336624378034587, + "weight_decay": 0.0010418641460534868, + "latent_dim": 33, + "beta_mi": 0.09289800538291174, + "beta_tc": 14.22442827306262, + "beta_dimKL": 0.009842271668763402, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 211, + "n_layers": 4, + "enc_factor": 2.7231671897160945, + "batch_size": 70, + "learning_rate": 0.0011741887096289845, + "drop_p": 0.15526478647654357, + "weight_decay": 6.224148156646825e-05, + "latent_dim": 38, + "beta_mi": 0.6376855171860635, + "beta_tc": 0.10045402488455435, + "beta_dimKL": 1.0635712656828507, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3346, + "n_layers": 4, + "enc_factor": 3.8037285324031584, + "batch_size": 52, + "learning_rate": 0.0037548911222877474, + "drop_p": 0.2521110143198393, + "weight_decay": 0.004929598709850626, + "latent_dim": 41, + "beta_mi": 5.79068942538511, + "beta_tc": 179.67270224473867, + "beta_dimKL": 0.0015999151302083245, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 839, + "n_layers": 3, + "enc_factor": 3.3323475084297693, + "batch_size": 220, + "learning_rate": 0.0017343862121499208, + "drop_p": 0.35633134652365195, + "weight_decay": 0.0016970772464659854, + "latent_dim": 46, + "beta_mi": 0.13779921686316868, + "beta_tc": 8.136513733722621, + "beta_dimKL": 0.05436706505162664, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2146, + "n_layers": 2, + "enc_factor": 2.294158782471669, + "batch_size": 53, + "learning_rate": 0.000658782713558455, + "drop_p": 0.6276705657559581, + "weight_decay": 0.00014962975855875091, + "latent_dim": 25, + "beta_mi": 0.01489200678898855, + "beta_tc": 0.15019661299683246, + "beta_dimKL": 0.009076342452649698, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 195, + "n_layers": 3, + "enc_factor": 1.1906890387322848, + "batch_size": 232, + "learning_rate": 3.7197353715029424e-05, + "drop_p": 0.3684457352545963, + "weight_decay": 4.8530042697593865e-05, + "latent_dim": 52, + "beta_mi": 0.022016867037345088, + "beta_tc": 94.21906998261079, + "beta_dimKL": 0.015906103078497623, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 2239, + "n_layers": 3, + "enc_factor": 3.9340720849065165, + "batch_size": 244, + "learning_rate": 0.00016645220032795912, + "drop_p": 0.8548077323820203, + "weight_decay": 0.00395569071252175, + "latent_dim": 45, + "beta_mi": 3.457269925790864, + "beta_tc": 1.9039033080995547, + "beta_dimKL": 0.013752567017389427, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1835, + "n_layers": 4, + "enc_factor": 2.840149647028809, + "batch_size": 214, + "learning_rate": 1.6651869292675224e-05, + "drop_p": 0.4246836900154703, + "weight_decay": 7.91248146585265e-05, + "latent_dim": 60, + "beta_mi": 0.027631613955752442, + "beta_tc": 3.1064454219595343, + "beta_dimKL": 0.04089375281215901, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 222, + "n_layers": 3, + "enc_factor": 2.2429057797686407, + "batch_size": 135, + "learning_rate": 0.0016913159155603384, + "drop_p": 0.00041801384795272514, + "weight_decay": 0.0002966296774598369, + "latent_dim": 45, + "beta_mi": 0.07488697350104684, + "beta_tc": 7.239883901662545, + "beta_dimKL": 0.0014706561392259785, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 366, + "n_layers": 2, + "enc_factor": 2.9164193543020382, + "batch_size": 55, + "learning_rate": 4.353890520905142e-05, + "drop_p": 0.7354343100662769, + "weight_decay": 0.0009067923569244157, + "latent_dim": 40, + "beta_mi": 0.006196264665748725, + "beta_tc": 0.12157883214855467, + "beta_dimKL": 2.451427669063179, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 889, + "n_layers": 3, + "enc_factor": 3.673097911834839, + "batch_size": 248, + "learning_rate": 0.0006455665442074103, + "drop_p": 0.5843024189245127, + "weight_decay": 0.00088559762100201, + "latent_dim": 18, + "beta_mi": 0.0013641284671067338, + "beta_tc": 0.3147338428372606, + "beta_dimKL": 0.704860241217077, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 914, + "n_layers": 2, + "enc_factor": 2.65672568166738, + "batch_size": 78, + "learning_rate": 0.011943997778313639, + "drop_p": 0.4853628437182782, + "weight_decay": 0.004090151465930246, + "latent_dim": 26, + "beta_mi": 0.7104416617671334, + "beta_tc": 0.1143420214693522, + "beta_dimKL": 0.004562520434010538, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3105, + "n_layers": 4, + "enc_factor": 3.372656161513768, + "batch_size": 100, + "learning_rate": 3.208451226046035e-05, + "drop_p": 0.24393112562202582, + "weight_decay": 0.0030568223452643486, + "latent_dim": 8, + "beta_mi": 0.069653427625472, + "beta_tc": 0.30982922288292786, + "beta_dimKL": 0.013315597324850603, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 283, + "n_layers": 3, + "enc_factor": 1.4017631787374656, + "batch_size": 199, + "learning_rate": 0.00013015425776211263, + "drop_p": 0.11887808395299138, + "weight_decay": 3.518978590382205e-05, + "latent_dim": 20, + "beta_mi": 0.6195816780412112, + "beta_tc": 0.5416891581660656, + "beta_dimKL": 0.009003918195874473, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1401, + "n_layers": 3, + "enc_factor": 1.4852765758435535, + "batch_size": 70, + "learning_rate": 0.05216334214974263, + "drop_p": 0.8642909113879378, + "weight_decay": 1.0596442590070436e-05, + "latent_dim": 4, + "beta_mi": 0.11515497842035012, + "beta_tc": 1594.4985574342354, + "beta_dimKL": 0.0019101142919932788, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2840, + "n_layers": 2, + "enc_factor": 3.0797359888014806, + "batch_size": 244, + "learning_rate": 0.0071932522078677905, + "drop_p": 0.5805707646155795, + "weight_decay": 0.07430182545071772, + "latent_dim": 38, + "beta_mi": 0.16700047659168046, + "beta_tc": 74.64814025269358, + "beta_dimKL": 8.029148914489436, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 145, + "n_layers": 2, + "enc_factor": 2.260391605706182, + "batch_size": 207, + "learning_rate": 0.01652341490450237, + "drop_p": 0.2895283603582966, + "weight_decay": 0.006110923137681907, + "latent_dim": 55, + "beta_mi": 0.033740212428916956, + "beta_tc": 12.641398982303771, + "beta_dimKL": 0.14366228066428535, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 241, + "n_layers": 2, + "enc_factor": 1.278901058744131, + "batch_size": 215, + "learning_rate": 0.00039761698162678425, + "drop_p": 0.4262293328522858, + "weight_decay": 0.005667191198433267, + "latent_dim": 37, + "beta_mi": 0.11610856254271654, + "beta_tc": 710.8080986499857, + "beta_dimKL": 0.01842218629081774, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2983, + "n_layers": 3, + "enc_factor": 1.5502694678408837, + "batch_size": 183, + "learning_rate": 0.0016096312677809563, + "drop_p": 0.43976907337107957, + "weight_decay": 1.6569353491940228e-05, + "latent_dim": 31, + "beta_mi": 0.5754139045564092, + "beta_tc": 27.93503025809686, + "beta_dimKL": 0.03509512613886498, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 946, + "n_layers": 3, + "enc_factor": 1.7330364445218853, + "batch_size": 96, + "learning_rate": 0.006236989403153801, + "drop_p": 0.15875491956103088, + "weight_decay": 0.0035329201251543987, + "latent_dim": 35, + "beta_mi": 0.0016476185033493182, + "beta_tc": 3279.800183529407, + "beta_dimKL": 0.007239017741134601, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1366, + "n_layers": 3, + "enc_factor": 2.2484108127575353, + "batch_size": 217, + "learning_rate": 2.789147935397925e-05, + "drop_p": 0.8630452143350769, + "weight_decay": 0.000383249011351772, + "latent_dim": 19, + "beta_mi": 1.4666379791052637, + "beta_tc": 17.235516912313418, + "beta_dimKL": 2.175336796043372, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1102, + "n_layers": 4, + "enc_factor": 1.8996081785797982, + "batch_size": 230, + "learning_rate": 0.03146439642723271, + "drop_p": 0.4737497670819176, + "weight_decay": 2.691845225547284e-05, + "latent_dim": 60, + "beta_mi": 0.0337694240192135, + "beta_tc": 5.9921155276103635, + "beta_dimKL": 2.2571625976780414, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 160, + "n_layers": 3, + "enc_factor": 1.2015517960056683, + "batch_size": 248, + "learning_rate": 0.003913511112427204, + "drop_p": 0.03188538136413253, + "weight_decay": 0.001009912743641097, + "latent_dim": 51, + "beta_mi": 0.0018227978040425879, + "beta_tc": 0.13503464948832042, + "beta_dimKL": 0.001658091828498944, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 1382, + "n_layers": 2, + "enc_factor": 2.159456402120137, + "batch_size": 119, + "learning_rate": 0.01641692764263181, + "drop_p": 0.25522302453236173, + "weight_decay": 0.00907036532994457, + "latent_dim": 58, + "beta_mi": 7.449978500915778, + "beta_tc": 0.6345627258574823, + "beta_dimKL": 0.0032528335607656415, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 352, + "n_layers": 3, + "enc_factor": 2.7287915189168546, + "batch_size": 180, + "learning_rate": 0.005563532442470447, + "drop_p": 0.43979982309631654, + "weight_decay": 3.086161920797189e-05, + "latent_dim": 8, + "beta_mi": 0.0011863481646431976, + "beta_tc": 1.659432598711015, + "beta_dimKL": 0.0010065882811946686, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 236, + "n_layers": 3, + "enc_factor": 3.401616004715218, + "batch_size": 65, + "learning_rate": 9.439140531266673e-05, + "drop_p": 0.27467026730017846, + "weight_decay": 6.068574460320074e-05, + "latent_dim": 47, + "beta_mi": 0.0011584293808002252, + "beta_tc": 8.33948149083875, + "beta_dimKL": 0.1692132256482031, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1185, + "n_layers": 4, + "enc_factor": 3.451339096844836, + "batch_size": 153, + "learning_rate": 0.019966912044025738, + "drop_p": 0.7267582389830913, + "weight_decay": 1.3651829815868236e-05, + "latent_dim": 44, + "beta_mi": 8.124130004105437, + "beta_tc": 9.810890185326636, + "beta_dimKL": 0.009595767306183745, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2817, + "n_layers": 3, + "enc_factor": 1.7424451363883078, + "batch_size": 97, + "learning_rate": 0.026717754239878794, + "drop_p": 0.5816648339426147, + "weight_decay": 4.0121861697948385e-05, + "latent_dim": 12, + "beta_mi": 0.006207406052870509, + "beta_tc": 0.32130333724358756, + "beta_dimKL": 7.897231858500386, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 162, + "n_layers": 3, + "enc_factor": 3.9897080422378375, + "batch_size": 106, + "learning_rate": 0.0040488520887873546, + "drop_p": 0.048598662213863976, + "weight_decay": 1.3643847468233593e-05, + "latent_dim": 17, + "beta_mi": 0.9032594452769385, + "beta_tc": 0.4016403963083231, + "beta_dimKL": 0.0012836114399140362, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2418, + "n_layers": 3, + "enc_factor": 1.8874642726856874, + "batch_size": 187, + "learning_rate": 0.009446336734018014, + "drop_p": 0.7155729598593135, + "weight_decay": 7.368977981038499e-05, + "latent_dim": 11, + "beta_mi": 0.44962054312219485, + "beta_tc": 405.76152548249433, + "beta_dimKL": 0.04391822967250848, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2619, + "n_layers": 3, + "enc_factor": 1.2803083346940936, + "batch_size": 183, + "learning_rate": 0.04496731596151852, + "drop_p": 0.374486768211674, + "weight_decay": 0.0004954834671046874, + "latent_dim": 57, + "beta_mi": 8.855420974725444, + "beta_tc": 9702.57628642998, + "beta_dimKL": 0.25058199566294515, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 142, + "n_layers": 3, + "enc_factor": 2.278788566068345, + "batch_size": 82, + "learning_rate": 5.7455106515369934e-05, + "drop_p": 0.17664970232201124, + "weight_decay": 0.021940459965525173, + "latent_dim": 49, + "beta_mi": 0.12668304936308836, + "beta_tc": 0.29486544170012047, + "beta_dimKL": 0.029719791745192976, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 944, + "n_layers": 4, + "enc_factor": 3.9842688967182642, + "batch_size": 61, + "learning_rate": 2.0460173171332855e-05, + "drop_p": 0.6031751012096852, + "weight_decay": 0.0003690875388544335, + "latent_dim": 19, + "beta_mi": 0.0011998861756273068, + "beta_tc": 51.560568058890404, + "beta_dimKL": 0.023809579726415474, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 1947, + "n_layers": 3, + "enc_factor": 3.390751187981618, + "batch_size": 129, + "learning_rate": 0.0005707235857695483, + "drop_p": 0.6622372138504743, + "weight_decay": 1.5866125635062043e-05, + "latent_dim": 13, + "beta_mi": 0.32503138097410716, + "beta_tc": 153.89064422124264, + "beta_dimKL": 0.04478405761292372, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 235, + "n_layers": 4, + "enc_factor": 1.3828108400271968, + "batch_size": 201, + "learning_rate": 0.0006480910289611438, + "drop_p": 0.22054472978708756, + "weight_decay": 0.002990514229028215, + "latent_dim": 33, + "beta_mi": 0.0908453357044565, + "beta_tc": 4.297205312374472, + "beta_dimKL": 0.0037581388798126362, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1055, + "n_layers": 3, + "enc_factor": 1.263626452875783, + "batch_size": 135, + "learning_rate": 0.0003913983251009171, + "drop_p": 0.6910026683822629, + "weight_decay": 0.0012640319732121954, + "latent_dim": 44, + "beta_mi": 0.5312519400190235, + "beta_tc": 0.32579185958724943, + "beta_dimKL": 0.00253677149002099, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 641, + "n_layers": 2, + "enc_factor": 2.258897030826775, + "batch_size": 248, + "learning_rate": 0.04170044423266357, + "drop_p": 0.0688600576893129, + "weight_decay": 0.04902794141046315, + "latent_dim": 40, + "beta_mi": 1.8513150616995373, + "beta_tc": 1394.553813940483, + "beta_dimKL": 1.0783301122819866, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1353, + "n_layers": 3, + "enc_factor": 3.586308546047407, + "batch_size": 43, + "learning_rate": 0.001441573502045038, + "drop_p": 0.4669683057222599, + "weight_decay": 0.0009707190602291024, + "latent_dim": 42, + "beta_mi": 0.047741481021755815, + "beta_tc": 1.9764957585391563, + "beta_dimKL": 0.06805767535976834, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 307, + "n_layers": 4, + "enc_factor": 3.076564141150584, + "batch_size": 245, + "learning_rate": 4.3248926801188796e-05, + "drop_p": 0.21684827669769383, + "weight_decay": 0.09425831013177162, + "latent_dim": 38, + "beta_mi": 0.002514446063493809, + "beta_tc": 0.2011263451431449, + "beta_dimKL": 3.4095319261575923, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 463, + "n_layers": 2, + "enc_factor": 2.900413327462081, + "batch_size": 146, + "learning_rate": 0.002169196549026143, + "drop_p": 0.6048324475356106, + "weight_decay": 1.4800253727747035e-05, + "latent_dim": 10, + "beta_mi": 1.2338179907817914, + "beta_tc": 23.191341394354804, + "beta_dimKL": 0.4067709023951524, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1170, + "n_layers": 4, + "enc_factor": 2.877584852997265, + "batch_size": 245, + "learning_rate": 0.0001738769901817764, + "drop_p": 0.40957968976554376, + "weight_decay": 0.09754612082659903, + "latent_dim": 42, + "beta_mi": 0.0036465157993520376, + "beta_tc": 1136.238319046297, + "beta_dimKL": 0.003199264590934543, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2941, + "n_layers": 2, + "enc_factor": 1.2088753826299359, + "batch_size": 47, + "learning_rate": 0.04126601750077339, + "drop_p": 0.8726595530300609, + "weight_decay": 0.005532683869378342, + "latent_dim": 12, + "beta_mi": 0.21402920429855796, + "beta_tc": 31.24568423718695, + "beta_dimKL": 0.0017713925057556796, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1019, + "n_layers": 3, + "enc_factor": 3.3838042327806193, + "batch_size": 100, + "learning_rate": 0.007488847393979452, + "drop_p": 0.1518864450665074, + "weight_decay": 0.04120607041984132, + "latent_dim": 35, + "beta_mi": 2.523211969148594, + "beta_tc": 2759.9293853960835, + "beta_dimKL": 4.0466425442836735, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 141, + "n_layers": 4, + "enc_factor": 3.7554829262268203, + "batch_size": 159, + "learning_rate": 0.00983298949183602, + "drop_p": 0.14135774795243208, + "weight_decay": 3.604504764381089e-05, + "latent_dim": 17, + "beta_mi": 0.8520052929271662, + "beta_tc": 64.34351083222086, + "beta_dimKL": 0.0011856793162072924, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2561, + "n_layers": 3, + "enc_factor": 2.782680330678602, + "batch_size": 250, + "learning_rate": 0.004415945221641974, + "drop_p": 0.6219149554366937, + "weight_decay": 6.0979912814445565e-05, + "latent_dim": 20, + "beta_mi": 0.41375448122421415, + "beta_tc": 352.1232526148499, + "beta_dimKL": 0.0038594185100736056, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2345, + "n_layers": 2, + "enc_factor": 1.1615946662520749, + "batch_size": 246, + "learning_rate": 0.00011815598531730829, + "drop_p": 0.49882673606014727, + "weight_decay": 0.014151393750345598, + "latent_dim": 26, + "beta_mi": 0.05810638925613893, + "beta_tc": 118.78322585185066, + "beta_dimKL": 6.63809534136652, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1612, + "n_layers": 3, + "enc_factor": 3.089365234452985, + "batch_size": 67, + "learning_rate": 0.00017447091821063112, + "drop_p": 0.07303584765572467, + "weight_decay": 0.000674551058036483, + "latent_dim": 5, + "beta_mi": 2.818474818270418, + "beta_tc": 2.8696454574954426, + "beta_dimKL": 0.7914973858222174, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2206, + "n_layers": 3, + "enc_factor": 2.769188250991352, + "batch_size": 167, + "learning_rate": 0.0002181818571440628, + "drop_p": 0.1756018823694824, + "weight_decay": 0.03693309399371587, + "latent_dim": 62, + "beta_mi": 0.004432443213173889, + "beta_tc": 0.23457346584591457, + "beta_dimKL": 0.3743451689832665, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 430, + "n_layers": 3, + "enc_factor": 3.2087758231503556, + "batch_size": 199, + "learning_rate": 0.0009806025566611845, + "drop_p": 0.6669822152602675, + "weight_decay": 1.982065258164605e-05, + "latent_dim": 4, + "beta_mi": 0.02005409079315229, + "beta_tc": 1.8062192847143286, + "beta_dimKL": 0.0032930609416051424, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3842, + "n_layers": 4, + "enc_factor": 2.2146757431417603, + "batch_size": 255, + "learning_rate": 0.044781117029689045, + "drop_p": 0.47819099989196356, + "weight_decay": 0.01720530659224413, + "latent_dim": 20, + "beta_mi": 1.3037349716327127, + "beta_tc": 78.50746723947823, + "beta_dimKL": 2.195049434096836, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 150, + "n_layers": 3, + "enc_factor": 1.5390380813209865, + "batch_size": 184, + "learning_rate": 0.003706840520645539, + "drop_p": 0.4355397537279102, + "weight_decay": 1.4202327978656575e-05, + "latent_dim": 48, + "beta_mi": 0.020188637585947945, + "beta_tc": 5.484809910370168, + "beta_dimKL": 0.0018649752872446001, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1010, + "n_layers": 3, + "enc_factor": 2.183188269178781, + "batch_size": 129, + "learning_rate": 0.000391531295227043, + "drop_p": 0.78508258402045, + "weight_decay": 0.029580766737293318, + "latent_dim": 10, + "beta_mi": 0.2234669870653387, + "beta_tc": 118.92120001583575, + "beta_dimKL": 0.7165235025082665, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 891, + "n_layers": 4, + "enc_factor": 2.0826975402465493, + "batch_size": 191, + "learning_rate": 4.108342066354317e-05, + "drop_p": 0.7436493297898782, + "weight_decay": 0.009204116980743991, + "latent_dim": 15, + "beta_mi": 0.6339763640612148, + "beta_tc": 2.9454084603929416, + "beta_dimKL": 1.8858855385130848, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + }, + "tcga": { + "downstream": [ + { + "k_filter": 1616, + "n_layers": 2, + "enc_factor": 3.027564369456143, + "batch_size": 160, + "learning_rate": 0.005156841933664806, + "drop_p": 0.2726176534838804, + "weight_decay": 0.021582810850797732, + "latent_dim": 28, + "beta_mi": 0.02935714720579787, + "beta_tc": 21.713616066376673, + "beta_dimKL": 0.019207491704279645, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2615, + "n_layers": 2, + "enc_factor": 2.6188717389884015, + "batch_size": 153, + "learning_rate": 0.0019088860276746558, + "drop_p": 0.07711080653785467, + "weight_decay": 0.0014009622266419857, + "latent_dim": 19, + "beta_mi": 0.15052301697536996, + "beta_tc": 0.15399223024116512, + "beta_dimKL": 0.003063422679533915, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3567, + "n_layers": 4, + "enc_factor": 3.6847211672404723, + "batch_size": 167, + "learning_rate": 0.06804126054784923, + "drop_p": 0.44441821473406146, + "weight_decay": 1.2715933287469943e-05, + "latent_dim": 11, + "beta_mi": 3.1734085159242147, + "beta_tc": 47.942757128091664, + "beta_dimKL": 0.21620101036120778, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 881, + "n_layers": 2, + "enc_factor": 3.4233970435031327, + "batch_size": 112, + "learning_rate": 0.006994483319387703, + "drop_p": 0.6393683337646953, + "weight_decay": 3.3381507279832714e-05, + "latent_dim": 57, + "beta_mi": 0.11724505508848596, + "beta_tc": 3.0676362033805367, + "beta_dimKL": 0.0013254685643874125, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3522, + "n_layers": 4, + "enc_factor": 2.1484616532140546, + "batch_size": 171, + "learning_rate": 0.014307690288342412, + "drop_p": 0.6225234113865529, + "weight_decay": 4.716036775718405e-05, + "latent_dim": 58, + "beta_mi": 9.076252703564242, + "beta_tc": 3.459159995152462, + "beta_dimKL": 1.5837716746663886, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2996, + "n_layers": 2, + "enc_factor": 2.2792982344790675, + "batch_size": 194, + "learning_rate": 0.00038097963657793586, + "drop_p": 0.15487253775427182, + "weight_decay": 0.00681456458783407, + "latent_dim": 50, + "beta_mi": 0.08374522522034357, + "beta_tc": 0.11602863850707283, + "beta_dimKL": 0.0013266203289644082, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 418, + "n_layers": 2, + "enc_factor": 3.777400017180793, + "batch_size": 213, + "learning_rate": 0.0004831746535024785, + "drop_p": 0.09993030007237654, + "weight_decay": 2.994633964649639e-05, + "latent_dim": 40, + "beta_mi": 0.0032396480370432633, + "beta_tc": 0.16468781287626144, + "beta_dimKL": 0.041803504962339415, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2924, + "n_layers": 3, + "enc_factor": 2.6608067715167363, + "batch_size": 148, + "learning_rate": 0.0004925633891588834, + "drop_p": 0.3761789412232611, + "weight_decay": 0.005174382231275261, + "latent_dim": 20, + "beta_mi": 8.461351626252283, + "beta_tc": 18.85025931112182, + "beta_dimKL": 0.07780404695409418, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2281, + "n_layers": 4, + "enc_factor": 1.2645089248869616, + "batch_size": 114, + "learning_rate": 0.005456232401703734, + "drop_p": 0.0721682906357851, + "weight_decay": 0.00022581831129776138, + "latent_dim": 38, + "beta_mi": 0.0021064022429282095, + "beta_tc": 0.3476699446684533, + "beta_dimKL": 0.025279075795686806, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1032, + "n_layers": 3, + "enc_factor": 3.2522120548383695, + "batch_size": 227, + "learning_rate": 4.257321060848766e-05, + "drop_p": 0.5507114937892199, + "weight_decay": 0.020748020481935678, + "latent_dim": 54, + "beta_mi": 0.0351961471220794, + "beta_tc": 20.63921663473724, + "beta_dimKL": 4.823434075704161, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 525, + "n_layers": 3, + "enc_factor": 1.3611782597047015, + "batch_size": 41, + "learning_rate": 0.032725634689205474, + "drop_p": 0.2021065308703048, + "weight_decay": 0.0466697087633557, + "latent_dim": 48, + "beta_mi": 9.471456932835219, + "beta_tc": 1408.758344882714, + "beta_dimKL": 0.056714176349792034, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 182, + "n_layers": 3, + "enc_factor": 1.2802852521851622, + "batch_size": 240, + "learning_rate": 0.0008289212257630114, + "drop_p": 0.5473870024561295, + "weight_decay": 0.0004154958752702763, + "latent_dim": 41, + "beta_mi": 0.002722601339182305, + "beta_tc": 85.12430212951966, + "beta_dimKL": 0.002763271243857093, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2132, + "n_layers": 3, + "enc_factor": 2.0375626934203352, + "batch_size": 158, + "learning_rate": 1.3440451505422832e-05, + "drop_p": 0.44208907955914434, + "weight_decay": 0.04842106009171422, + "latent_dim": 62, + "beta_mi": 0.0023761150581949075, + "beta_tc": 9.36326658695667, + "beta_dimKL": 7.7197903374428565, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3581, + "n_layers": 3, + "enc_factor": 3.264899962396023, + "batch_size": 41, + "learning_rate": 0.0001325211883059514, + "drop_p": 0.41708435669398664, + "weight_decay": 0.0007246181666809848, + "latent_dim": 41, + "beta_mi": 0.1100692039235532, + "beta_tc": 1746.9251748882696, + "beta_dimKL": 3.1676464277166096, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2993, + "n_layers": 4, + "enc_factor": 1.234212914007769, + "batch_size": 88, + "learning_rate": 0.042336393775875225, + "drop_p": 0.2784590568165273, + "weight_decay": 0.000910714732508229, + "latent_dim": 7, + "beta_mi": 0.7713349142020895, + "beta_tc": 25.10729914674151, + "beta_dimKL": 0.0028689679181256567, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 147, + "n_layers": 2, + "enc_factor": 3.7659232389006894, + "batch_size": 235, + "learning_rate": 0.01061576463474892, + "drop_p": 0.14005574965478151, + "weight_decay": 0.003635752722757181, + "latent_dim": 42, + "beta_mi": 0.029072778699751257, + "beta_tc": 2.7243840610672923, + "beta_dimKL": 0.15182607167470727, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 155, + "n_layers": 3, + "enc_factor": 1.915206275926784, + "batch_size": 87, + "learning_rate": 5.378766229328644e-05, + "drop_p": 0.5889262022419965, + "weight_decay": 9.195055727619021e-05, + "latent_dim": 45, + "beta_mi": 0.20214802349056415, + "beta_tc": 22.122856271440707, + "beta_dimKL": 0.00179015278576344, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 189, + "n_layers": 4, + "enc_factor": 1.9565116295000493, + "batch_size": 193, + "learning_rate": 0.0006597769082268572, + "drop_p": 0.6868418234150045, + "weight_decay": 0.0004250042231851869, + "latent_dim": 43, + "beta_mi": 2.5346304397075867, + "beta_tc": 106.79587359085352, + "beta_dimKL": 0.15778132362319353, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3048, + "n_layers": 2, + "enc_factor": 1.0303535261630703, + "batch_size": 244, + "learning_rate": 0.0005403415513755819, + "drop_p": 0.11845585123235146, + "weight_decay": 0.0020905522621984416, + "latent_dim": 50, + "beta_mi": 0.03190455957582684, + "beta_tc": 2.4475373243577283, + "beta_dimKL": 0.08422493772276443, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1935, + "n_layers": 3, + "enc_factor": 3.8045433360863825, + "batch_size": 82, + "learning_rate": 0.02438031444938648, + "drop_p": 0.015077359800216872, + "weight_decay": 0.006177393887460923, + "latent_dim": 57, + "beta_mi": 0.29706536887347346, + "beta_tc": 0.17810886972024048, + "beta_dimKL": 0.5862981696101738, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 174, + "n_layers": 3, + "enc_factor": 1.8979922005295307, + "batch_size": 234, + "learning_rate": 0.0001413703608102043, + "drop_p": 0.2195750008808655, + "weight_decay": 0.002171297567750286, + "latent_dim": 60, + "beta_mi": 0.12395379710829872, + "beta_tc": 3673.652350048961, + "beta_dimKL": 1.991971609463465, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1538, + "n_layers": 3, + "enc_factor": 3.537933754969064, + "batch_size": 85, + "learning_rate": 5.2537416743457074e-05, + "drop_p": 0.6627449542186169, + "weight_decay": 0.002180497931871148, + "latent_dim": 62, + "beta_mi": 0.016249532074905485, + "beta_tc": 44.539267349689, + "beta_dimKL": 0.03145686120998448, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 224, + "n_layers": 3, + "enc_factor": 1.685541226179311, + "batch_size": 249, + "learning_rate": 0.03200705085631841, + "drop_p": 0.1602459478257617, + "weight_decay": 0.0003108473078375217, + "latent_dim": 62, + "beta_mi": 0.003028165677669462, + "beta_tc": 30.09489985568906, + "beta_dimKL": 1.4158856986100261, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 465, + "n_layers": 2, + "enc_factor": 1.9303053450487542, + "batch_size": 39, + "learning_rate": 0.008262327942055024, + "drop_p": 0.15779201106114976, + "weight_decay": 0.02385785443528111, + "latent_dim": 57, + "beta_mi": 0.11271823624119082, + "beta_tc": 1.0154883270398478, + "beta_dimKL": 0.07264054328397533, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3112, + "n_layers": 2, + "enc_factor": 1.826813682475032, + "batch_size": 202, + "learning_rate": 0.00015747640279317081, + "drop_p": 0.5986406277233454, + "weight_decay": 0.06413036057631694, + "latent_dim": 22, + "beta_mi": 0.5039761922191451, + "beta_tc": 0.1715043428303581, + "beta_dimKL": 0.320640245100246, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3295, + "n_layers": 4, + "enc_factor": 3.1482934776537324, + "batch_size": 108, + "learning_rate": 0.011063697276689734, + "drop_p": 0.09359919387278501, + "weight_decay": 0.0009760195211371492, + "latent_dim": 44, + "beta_mi": 0.16131428381825336, + "beta_tc": 0.7925379991165522, + "beta_dimKL": 0.5288692509694314, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 206, + "n_layers": 3, + "enc_factor": 2.7977460194818344, + "batch_size": 38, + "learning_rate": 0.0023570697031902624, + "drop_p": 0.03539965587692916, + "weight_decay": 5.1897837350215765e-05, + "latent_dim": 33, + "beta_mi": 0.001107180392607658, + "beta_tc": 0.12266543225062308, + "beta_dimKL": 0.010792295856370565, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 249, + "n_layers": 3, + "enc_factor": 3.6823837145783633, + "batch_size": 237, + "learning_rate": 0.00021306997663450976, + "drop_p": 0.2962508735387303, + "weight_decay": 0.08921900930814919, + "latent_dim": 10, + "beta_mi": 0.09299395635892305, + "beta_tc": 0.14147441359158672, + "beta_dimKL": 0.007844530153005628, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 330, + "n_layers": 3, + "enc_factor": 3.2265659154570647, + "batch_size": 181, + "learning_rate": 0.0009317582889404343, + "drop_p": 0.417377610241884, + "weight_decay": 1.0968911513934147e-05, + "latent_dim": 15, + "beta_mi": 0.6487931817891026, + "beta_tc": 4.000256963134476, + "beta_dimKL": 0.1314779595926059, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 237, + "n_layers": 3, + "enc_factor": 1.2460399069106973, + "batch_size": 66, + "learning_rate": 0.0752672223993852, + "drop_p": 0.44864956146070156, + "weight_decay": 9.236006250625255e-05, + "latent_dim": 33, + "beta_mi": 0.10719120379890615, + "beta_tc": 1237.0130671223512, + "beta_dimKL": 2.8974764406799722, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 347, + "n_layers": 2, + "enc_factor": 1.982281894533114, + "batch_size": 86, + "learning_rate": 0.0014272352791190298, + "drop_p": 0.43201038771080674, + "weight_decay": 0.00010361754740364083, + "latent_dim": 7, + "beta_mi": 2.06113395934158, + "beta_tc": 9016.430733796613, + "beta_dimKL": 7.541314042863369, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3949, + "n_layers": 3, + "enc_factor": 2.098433055340512, + "batch_size": 195, + "learning_rate": 0.0007450049485194168, + "drop_p": 0.7362852172281349, + "weight_decay": 0.028400063046691362, + "latent_dim": 42, + "beta_mi": 0.005196554201918544, + "beta_tc": 4608.2496852295035, + "beta_dimKL": 0.0017060133871472079, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 160, + "n_layers": 3, + "enc_factor": 3.0173144622350927, + "batch_size": 176, + "learning_rate": 0.004523945682765439, + "drop_p": 0.5033180887954122, + "weight_decay": 1.766420649775029e-05, + "latent_dim": 4, + "beta_mi": 0.025007979063035802, + "beta_tc": 5763.174626044114, + "beta_dimKL": 0.7920714630058995, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 146, + "n_layers": 3, + "enc_factor": 3.6028819478366967, + "batch_size": 46, + "learning_rate": 0.00033643309413862064, + "drop_p": 0.01633560010080275, + "weight_decay": 0.00016186280335951447, + "latent_dim": 53, + "beta_mi": 0.030270915501291157, + "beta_tc": 19.35527029281268, + "beta_dimKL": 0.04056420775454454, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 200, + "n_layers": 3, + "enc_factor": 1.4550505808296859, + "batch_size": 119, + "learning_rate": 0.004007833496209405, + "drop_p": 0.2446343963069468, + "weight_decay": 0.0020394345738509252, + "latent_dim": 16, + "beta_mi": 0.04639477495534082, + "beta_tc": 25.546672448829273, + "beta_dimKL": 0.001233024417284946, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 600, + "n_layers": 3, + "enc_factor": 1.5220756706555618, + "batch_size": 82, + "learning_rate": 0.005669805997864619, + "drop_p": 0.2760985207487351, + "weight_decay": 0.012100559422501465, + "latent_dim": 31, + "beta_mi": 0.11734730317676004, + "beta_tc": 11.853174670296315, + "beta_dimKL": 1.7407980334172666, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3602, + "n_layers": 4, + "enc_factor": 1.507091866021412, + "batch_size": 47, + "learning_rate": 0.05040921732288227, + "drop_p": 0.032403258579482376, + "weight_decay": 0.00520859874245934, + "latent_dim": 51, + "beta_mi": 0.07216897400350178, + "beta_tc": 2978.969140985781, + "beta_dimKL": 0.865617070590043, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 508, + "n_layers": 3, + "enc_factor": 2.3587764437689764, + "batch_size": 52, + "learning_rate": 0.07545431117639437, + "drop_p": 0.4436725925423945, + "weight_decay": 0.0005886714472587053, + "latent_dim": 35, + "beta_mi": 0.02620547966804055, + "beta_tc": 6.325316296915757, + "beta_dimKL": 0.0069835994570617965, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 151, + "n_layers": 2, + "enc_factor": 2.5409905418707535, + "batch_size": 66, + "learning_rate": 0.014540652531931101, + "drop_p": 0.7541847769027215, + "weight_decay": 6.421990491086303e-05, + "latent_dim": 44, + "beta_mi": 0.29554167413994764, + "beta_tc": 0.8595053736181086, + "beta_dimKL": 0.007522433153354028, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 234, + "n_layers": 2, + "enc_factor": 1.4631010327730853, + "batch_size": 230, + "learning_rate": 0.003704930982177108, + "drop_p": 0.1491196614457038, + "weight_decay": 0.0051208314753429, + "latent_dim": 22, + "beta_mi": 0.001610726246885538, + "beta_tc": 0.29669248422490013, + "beta_dimKL": 0.011372371034058176, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 240, + "n_layers": 2, + "enc_factor": 1.612301716464282, + "batch_size": 228, + "learning_rate": 4.3824412279683916e-05, + "drop_p": 0.18397291522880024, + "weight_decay": 0.017402437079688082, + "latent_dim": 53, + "beta_mi": 0.021135959297820778, + "beta_tc": 1.1203354423818772, + "beta_dimKL": 0.5620204847856625, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3215, + "n_layers": 4, + "enc_factor": 2.144475834335183, + "batch_size": 38, + "learning_rate": 0.0015464654787021128, + "drop_p": 0.6663883289293818, + "weight_decay": 3.785062143000985e-05, + "latent_dim": 5, + "beta_mi": 0.023387722026077844, + "beta_tc": 1.6252614560503018, + "beta_dimKL": 0.0022251723838263423, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 176, + "n_layers": 2, + "enc_factor": 2.5940958379618655, + "batch_size": 116, + "learning_rate": 0.007879639415450888, + "drop_p": 0.39807192253749485, + "weight_decay": 0.00022527195944975137, + "latent_dim": 46, + "beta_mi": 0.0010452906461247838, + "beta_tc": 167.01046759537792, + "beta_dimKL": 0.013862901534965257, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 152, + "n_layers": 2, + "enc_factor": 1.7067674708663931, + "batch_size": 82, + "learning_rate": 0.006099521588414504, + "drop_p": 0.15943874413515136, + "weight_decay": 0.0016190020800840616, + "latent_dim": 22, + "beta_mi": 4.779531358647342, + "beta_tc": 0.7753149646428443, + "beta_dimKL": 0.0036057513260594675, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 4020, + "n_layers": 3, + "enc_factor": 3.2992516163001295, + "batch_size": 48, + "learning_rate": 0.00034454793461318384, + "drop_p": 0.39987218325511675, + "weight_decay": 0.0026746545426661605, + "latent_dim": 32, + "beta_mi": 0.7953827049924708, + "beta_tc": 3977.195624208174, + "beta_dimKL": 0.00671095237977561, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 2161, + "n_layers": 3, + "enc_factor": 3.9080483325262, + "batch_size": 192, + "learning_rate": 0.0034283286896430944, + "drop_p": 0.23444924310589646, + "weight_decay": 1.771322995811936e-05, + "latent_dim": 45, + "beta_mi": 0.049554405358533726, + "beta_tc": 262.1195710672425, + "beta_dimKL": 0.0023570034614447386, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3738, + "n_layers": 4, + "enc_factor": 3.1265472551110682, + "batch_size": 243, + "learning_rate": 0.004268746656257051, + "drop_p": 0.1274273879600076, + "weight_decay": 1.5092202560961696e-05, + "latent_dim": 4, + "beta_mi": 0.03006796159212008, + "beta_tc": 96.51762997550455, + "beta_dimKL": 1.1293369710033088, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 236, + "n_layers": 3, + "enc_factor": 3.6155550852246945, + "batch_size": 35, + "learning_rate": 0.00013991759977445063, + "drop_p": 0.8328359346028589, + "weight_decay": 0.0028772258995414146, + "latent_dim": 26, + "beta_mi": 2.4492627765816786, + "beta_tc": 1157.9474941152291, + "beta_dimKL": 0.3005075349239165, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 768, + "n_layers": 4, + "enc_factor": 1.506702339098064, + "batch_size": 232, + "learning_rate": 0.0028156647372507403, + "drop_p": 0.8472429266249548, + "weight_decay": 5.463076765737799e-05, + "latent_dim": 21, + "beta_mi": 0.0026930662200561227, + "beta_tc": 140.7782838606867, + "beta_dimKL": 1.9629855277578658, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 254, + "n_layers": 4, + "enc_factor": 1.6234405788244928, + "batch_size": 33, + "learning_rate": 0.004582496666331807, + "drop_p": 0.030017077376595338, + "weight_decay": 7.296093248739669e-05, + "latent_dim": 31, + "beta_mi": 0.0028054557415085383, + "beta_tc": 6.931720355466852, + "beta_dimKL": 0.10683256788596723, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 793, + "n_layers": 2, + "enc_factor": 2.7137857537471195, + "batch_size": 225, + "learning_rate": 0.0005203255518688019, + "drop_p": 0.3056735405450907, + "weight_decay": 1.255538464296837e-05, + "latent_dim": 45, + "beta_mi": 0.03968690023659981, + "beta_tc": 0.24362215553117147, + "beta_dimKL": 0.06936478868262838, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 208, + "n_layers": 4, + "enc_factor": 2.2764212736808913, + "batch_size": 191, + "learning_rate": 0.001689610916992267, + "drop_p": 0.07181656005618939, + "weight_decay": 7.132657572094805e-05, + "latent_dim": 63, + "beta_mi": 7.344150812065508, + "beta_tc": 1.583679251820961, + "beta_dimKL": 0.010441491798331638, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2085, + "n_layers": 3, + "enc_factor": 3.0949428579183946, + "batch_size": 135, + "learning_rate": 0.00024815531292131756, + "drop_p": 0.6621380030177656, + "weight_decay": 0.027221956757484886, + "latent_dim": 55, + "beta_mi": 0.0114453845499277, + "beta_tc": 503.57135109152034, + "beta_dimKL": 0.0019448951686698625, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2634, + "n_layers": 4, + "enc_factor": 1.8373755005086547, + "batch_size": 33, + "learning_rate": 0.00013574651958859853, + "drop_p": 0.7084178041201495, + "weight_decay": 0.04808906188187551, + "latent_dim": 40, + "beta_mi": 0.027397876541356985, + "beta_tc": 2173.777258279002, + "beta_dimKL": 0.40219830347056995, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 138, + "n_layers": 2, + "enc_factor": 2.429949074003976, + "batch_size": 156, + "learning_rate": 0.0003261306548956053, + "drop_p": 0.6943606693881338, + "weight_decay": 1.3997007071078103e-05, + "latent_dim": 62, + "beta_mi": 0.001113915744622779, + "beta_tc": 0.2527737213407522, + "beta_dimKL": 0.030930495506535174, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 940, + "n_layers": 3, + "enc_factor": 2.4172678989202305, + "batch_size": 225, + "learning_rate": 0.0004291443683632536, + "drop_p": 0.23167175114383956, + "weight_decay": 0.00013485363921081245, + "latent_dim": 63, + "beta_mi": 0.014159406270400132, + "beta_tc": 153.15274331709537, + "beta_dimKL": 0.0537460294566775, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 1711, + "n_layers": 3, + "enc_factor": 3.9292296520250485, + "batch_size": 41, + "learning_rate": 9.570944013124035e-05, + "drop_p": 0.5508686709836487, + "weight_decay": 2.030117753024651e-05, + "latent_dim": 17, + "beta_mi": 0.006236684123561851, + "beta_tc": 13.17674832277359, + "beta_dimKL": 1.7927812256620785, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 490, + "n_layers": 3, + "enc_factor": 2.763902411199661, + "batch_size": 158, + "learning_rate": 0.0005701865913722152, + "drop_p": 0.4683123902785043, + "weight_decay": 0.004724525433515288, + "latent_dim": 25, + "beta_mi": 4.041427501043611, + "beta_tc": 1835.9309801279262, + "beta_dimKL": 0.061851242781525574, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 332, + "n_layers": 2, + "enc_factor": 2.4572660803665336, + "batch_size": 158, + "learning_rate": 0.00039205188958158047, + "drop_p": 0.2311936226654658, + "weight_decay": 0.0006065506909724717, + "latent_dim": 50, + "beta_mi": 0.0721518790136877, + "beta_tc": 0.1585611104285143, + "beta_dimKL": 0.004185320193785744, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3351, + "n_layers": 4, + "enc_factor": 1.8533806325272355, + "batch_size": 64, + "learning_rate": 0.04844186353587512, + "drop_p": 0.2885625664210874, + "weight_decay": 8.051801095683077e-05, + "latent_dim": 31, + "beta_mi": 0.22954805746543114, + "beta_tc": 9.462657700028311, + "beta_dimKL": 0.009265520380593967, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 299, + "n_layers": 2, + "enc_factor": 2.1329201365528094, + "batch_size": 114, + "learning_rate": 0.0003157132700737124, + "drop_p": 0.7274007849534286, + "weight_decay": 0.0016193716469567203, + "latent_dim": 60, + "beta_mi": 8.827847885990664, + "beta_tc": 466.8325087949554, + "beta_dimKL": 0.03170206639363823, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 166, + "n_layers": 3, + "enc_factor": 2.8389037525491747, + "batch_size": 64, + "learning_rate": 8.122632986699252e-05, + "drop_p": 0.2912953052360633, + "weight_decay": 0.004650949524560476, + "latent_dim": 32, + "beta_mi": 2.6698850534724126, + "beta_tc": 285.29889175589517, + "beta_dimKL": 0.013348483742850184, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 216, + "n_layers": 4, + "enc_factor": 2.884973656859593, + "batch_size": 107, + "learning_rate": 0.0018761680423435665, + "drop_p": 0.6751805249425624, + "weight_decay": 3.614863630769642e-05, + "latent_dim": 23, + "beta_mi": 0.31094767340259166, + "beta_tc": 271.0498296245341, + "beta_dimKL": 0.006274528623109432, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 136, + "n_layers": 3, + "enc_factor": 3.8997951518838154, + "batch_size": 124, + "learning_rate": 0.0008949661830301853, + "drop_p": 0.096419324932724, + "weight_decay": 0.0004231615822575032, + "latent_dim": 21, + "beta_mi": 0.054647837183877716, + "beta_tc": 0.7426614094755732, + "beta_dimKL": 0.005549046958636643, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3170, + "n_layers": 2, + "enc_factor": 3.7198771574150054, + "batch_size": 38, + "learning_rate": 0.010416367606663505, + "drop_p": 0.6796506784234573, + "weight_decay": 3.3852533797059215e-05, + "latent_dim": 6, + "beta_mi": 0.029671048094997928, + "beta_tc": 0.16237349581297436, + "beta_dimKL": 0.08722969618703325, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 3576, + "n_layers": 4, + "enc_factor": 3.438168238168346, + "batch_size": 211, + "learning_rate": 0.06628339760604982, + "drop_p": 0.27466833348215064, + "weight_decay": 1.1480762004997884e-05, + "latent_dim": 9, + "beta_mi": 0.001220715392958664, + "beta_tc": 5649.129996716436, + "beta_dimKL": 0.1992801473416326, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1309, + "n_layers": 3, + "enc_factor": 3.7565494945545077, + "batch_size": 109, + "learning_rate": 0.03241906851252533, + "drop_p": 0.6976115258370911, + "weight_decay": 1.546862387649669e-05, + "latent_dim": 13, + "beta_mi": 0.004293594432827267, + "beta_tc": 52.58734048969374, + "beta_dimKL": 0.5079987484861811, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 392, + "n_layers": 3, + "enc_factor": 3.7170900041635795, + "batch_size": 87, + "learning_rate": 0.002241140064722009, + "drop_p": 0.3144740184313553, + "weight_decay": 0.010833787429915927, + "latent_dim": 55, + "beta_mi": 0.10964745510227285, + "beta_tc": 0.21305283583798623, + "beta_dimKL": 2.334156630461663, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 170, + "n_layers": 4, + "enc_factor": 1.8801732772881563, + "batch_size": 107, + "learning_rate": 0.00027523550513071924, + "drop_p": 0.36904229271175404, + "weight_decay": 2.39748550340376e-05, + "latent_dim": 44, + "beta_mi": 0.542479387470207, + "beta_tc": 87.15579298945732, + "beta_dimKL": 0.00897217975462615, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2963, + "n_layers": 4, + "enc_factor": 3.8671168802503244, + "batch_size": 147, + "learning_rate": 0.00012789023341907869, + "drop_p": 0.3727300411603971, + "weight_decay": 0.06969464610863844, + "latent_dim": 63, + "beta_mi": 0.003920521337552874, + "beta_tc": 0.23596622512922702, + "beta_dimKL": 0.004303437552231212, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 402, + "n_layers": 3, + "enc_factor": 2.228302367588083, + "batch_size": 121, + "learning_rate": 0.0001685911866544581, + "drop_p": 0.7687598239413156, + "weight_decay": 0.0002292482718823646, + "latent_dim": 5, + "beta_mi": 0.0013428397841061472, + "beta_tc": 0.16127059616987213, + "beta_dimKL": 2.4824144150180065, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 184, + "n_layers": 3, + "enc_factor": 3.9577543368077137, + "batch_size": 190, + "learning_rate": 0.006370587282661631, + "drop_p": 0.4731942607644586, + "weight_decay": 0.00231814184910625, + "latent_dim": 22, + "beta_mi": 0.015042306973503717, + "beta_tc": 1.893120511899231, + "beta_dimKL": 6.683638444659881, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 174, + "n_layers": 3, + "enc_factor": 2.83345590799562, + "batch_size": 70, + "learning_rate": 0.018841571743340706, + "drop_p": 0.23513771501654954, + "weight_decay": 1.4028067698136238e-05, + "latent_dim": 29, + "beta_mi": 0.0900035370353195, + "beta_tc": 1.5714007873992113, + "beta_dimKL": 0.011559726715339126, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3003, + "n_layers": 3, + "enc_factor": 3.0615204170440142, + "batch_size": 184, + "learning_rate": 0.01068923976288823, + "drop_p": 0.5221803625423962, + "weight_decay": 0.0021460178218531407, + "latent_dim": 64, + "beta_mi": 0.1446671106332701, + "beta_tc": 1519.5922749977797, + "beta_dimKL": 0.0035123043288159935, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 190, + "n_layers": 2, + "enc_factor": 1.8763262521273085, + "batch_size": 202, + "learning_rate": 0.0024974610195874053, + "drop_p": 0.20737330219437666, + "weight_decay": 1.093550040412717e-05, + "latent_dim": 28, + "beta_mi": 1.58712497978352, + "beta_tc": 3.7512511509215027, + "beta_dimKL": 0.0011858688565842582, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2210, + "n_layers": 4, + "enc_factor": 3.015204203223699, + "batch_size": 219, + "learning_rate": 0.001869004064525606, + "drop_p": 0.06112817963787905, + "weight_decay": 0.000166874340333852, + "latent_dim": 44, + "beta_mi": 0.030680343903336703, + "beta_tc": 1.5471716689651747, + "beta_dimKL": 4.142041132556256, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1169, + "n_layers": 4, + "enc_factor": 3.761764479874515, + "batch_size": 90, + "learning_rate": 1.6056535335185988e-05, + "drop_p": 0.5675729284183167, + "weight_decay": 1.0409947438322788e-05, + "latent_dim": 41, + "beta_mi": 1.5063046242696114, + "beta_tc": 396.0183331075447, + "beta_dimKL": 0.005044603491777965, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 415, + "n_layers": 3, + "enc_factor": 2.923428347944205, + "batch_size": 150, + "learning_rate": 4.528415318859355e-05, + "drop_p": 0.3598343677739989, + "weight_decay": 0.0034735550151744226, + "latent_dim": 56, + "beta_mi": 0.09107462918196693, + "beta_tc": 40.440156681947364, + "beta_dimKL": 0.13298823426172593, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1361, + "n_layers": 3, + "enc_factor": 2.4193730872287573, + "batch_size": 191, + "learning_rate": 0.0002843492860288595, + "drop_p": 0.44235117121269907, + "weight_decay": 0.04033800624021204, + "latent_dim": 12, + "beta_mi": 0.017333663079262915, + "beta_tc": 1.1206720967168138, + "beta_dimKL": 0.078592509258887, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 177, + "n_layers": 2, + "enc_factor": 2.089799839228133, + "batch_size": 102, + "learning_rate": 0.0006679208045335424, + "drop_p": 0.10973232293766925, + "weight_decay": 3.3584838466019673e-05, + "latent_dim": 33, + "beta_mi": 0.0012029707709769468, + "beta_tc": 0.17244599599895968, + "beta_dimKL": 0.11163538887881155, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + }, + "schc": { + "downstream": [ + { + "k_filter": 3157, + "n_layers": 2, + "enc_factor": 3.381454655966518, + "batch_size": 116, + "learning_rate": 4.9702332215573145e-05, + "drop_p": 0.34032069373339163, + "weight_decay": 0.03608476066272391, + "latent_dim": 58, + "beta_mi": 0.037019775791651166, + "beta_tc": 0.23062695544290024, + "beta_dimKL": 0.0017778699475899493, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2160, + "n_layers": 3, + "enc_factor": 2.2961090095574517, + "batch_size": 142, + "learning_rate": 0.0020169640360725573, + "drop_p": 0.8357603727835763, + "weight_decay": 0.00026443940921748113, + "latent_dim": 53, + "beta_mi": 2.9558119792329527, + "beta_tc": 6.650231863044925, + "beta_dimKL": 3.2973911749954525, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1435, + "n_layers": 2, + "enc_factor": 2.9451461763540414, + "batch_size": 75, + "learning_rate": 0.00011041850181166743, + "drop_p": 0.53407848517869, + "weight_decay": 7.629798931761121e-05, + "latent_dim": 14, + "beta_mi": 0.03078452627900695, + "beta_tc": 320.160683672418, + "beta_dimKL": 0.13364172998258192, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2236, + "n_layers": 3, + "enc_factor": 2.233502137211649, + "batch_size": 77, + "learning_rate": 0.00038036640045504985, + "drop_p": 0.02214983726374825, + "weight_decay": 0.0038857378014868827, + "latent_dim": 60, + "beta_mi": 0.08506932143492649, + "beta_tc": 0.10084679047541116, + "beta_dimKL": 0.0016471515266171094, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3604, + "n_layers": 2, + "enc_factor": 1.2010254218556784, + "batch_size": 150, + "learning_rate": 0.0007434429159783924, + "drop_p": 0.011987531767488535, + "weight_decay": 7.608950772415024e-05, + "latent_dim": 58, + "beta_mi": 8.704198096482216, + "beta_tc": 1.3518828317672271, + "beta_dimKL": 0.08884651901818276, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2151, + "n_layers": 4, + "enc_factor": 2.579670675953983, + "batch_size": 117, + "learning_rate": 0.002845533308727398, + "drop_p": 0.44161103941939844, + "weight_decay": 0.025900606285422147, + "latent_dim": 17, + "beta_mi": 0.0030760622064254397, + "beta_tc": 0.1271071624006535, + "beta_dimKL": 0.007290281318894705, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2198, + "n_layers": 3, + "enc_factor": 1.4354869535860058, + "batch_size": 174, + "learning_rate": 0.011391145053174352, + "drop_p": 0.2857881141187856, + "weight_decay": 0.00014988792894739478, + "latent_dim": 31, + "beta_mi": 0.0013678066382814703, + "beta_tc": 4224.422736766651, + "beta_dimKL": 0.002118906518024187, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1872, + "n_layers": 2, + "enc_factor": 2.4542908903055327, + "batch_size": 62, + "learning_rate": 0.0003842722193601195, + "drop_p": 0.058624995530298665, + "weight_decay": 2.962811456394179e-05, + "latent_dim": 14, + "beta_mi": 0.8724029348686748, + "beta_tc": 7751.38598977641, + "beta_dimKL": 0.005116505286811906, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 3242, + "n_layers": 2, + "enc_factor": 3.5923480773657905, + "batch_size": 80, + "learning_rate": 3.249425084421757e-05, + "drop_p": 0.15590631927326462, + "weight_decay": 0.0069470330100444636, + "latent_dim": 36, + "beta_mi": 0.027824481763652417, + "beta_tc": 0.7612506182309976, + "beta_dimKL": 0.0012093706534173302, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2621, + "n_layers": 3, + "enc_factor": 1.3460646706645205, + "batch_size": 38, + "learning_rate": 1.5675378915477247e-05, + "drop_p": 0.05017355811018862, + "weight_decay": 0.0005961815907174485, + "latent_dim": 23, + "beta_mi": 0.004555223871543938, + "beta_tc": 0.15141233983372848, + "beta_dimKL": 0.10320778095299103, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ], + "reconstruction": { + "10": [ + { + "k_filter": 203, + "n_layers": 3, + "enc_factor": 2.0007158156000253, + "batch_size": 247, + "learning_rate": 0.03513053983395644, + "drop_p": 0.2683841841247308, + "weight_decay": 0.010227888785708364, + "latent_dim": 42, + "beta_mi": 0.1144665344693407, + "beta_tc": 6205.848526679116, + "beta_dimKL": 1.8011230980880055, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 242, + "n_layers": 4, + "enc_factor": 3.1945664849156623, + "batch_size": 186, + "learning_rate": 0.010893823333379673, + "drop_p": 0.3200860603933371, + "weight_decay": 2.330719828923887e-05, + "latent_dim": 48, + "beta_mi": 0.01635950883832069, + "beta_tc": 0.19566439864847235, + "beta_dimKL": 2.904265198177644, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 2962, + "n_layers": 3, + "enc_factor": 1.0542889819112713, + "batch_size": 79, + "learning_rate": 0.00010870885008770268, + "drop_p": 0.31481903604767375, + "weight_decay": 0.01196658704636224, + "latent_dim": 15, + "beta_mi": 0.0050583217110512675, + "beta_tc": 5693.749027913766, + "beta_dimKL": 0.9505378885698306, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 182, + "n_layers": 2, + "enc_factor": 3.723094207366199, + "batch_size": 104, + "learning_rate": 0.004705012746899576, + "drop_p": 0.10723033753750459, + "weight_decay": 0.0008711747220382666, + "latent_dim": 40, + "beta_mi": 0.12397615315120154, + "beta_tc": 958.1110148810072, + "beta_dimKL": 0.02258055144483052, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 3407, + "n_layers": 3, + "enc_factor": 3.664511212084078, + "batch_size": 37, + "learning_rate": 0.001619784417879413, + "drop_p": 0.23635983856805468, + "weight_decay": 0.008778382121305332, + "latent_dim": 14, + "beta_mi": 3.6431212263799475, + "beta_tc": 8186.442151339816, + "beta_dimKL": 0.0029120986112809635, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 156, + "n_layers": 4, + "enc_factor": 1.1152680442039062, + "batch_size": 122, + "learning_rate": 0.00012178741658304432, + "drop_p": 0.027701254611934956, + "weight_decay": 0.0063333275138587235, + "latent_dim": 24, + "beta_mi": 0.02576944616032013, + "beta_tc": 1539.4186745854902, + "beta_dimKL": 0.0023975847179569906, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 650, + "n_layers": 2, + "enc_factor": 1.7999182276605272, + "batch_size": 174, + "learning_rate": 0.060410352516520965, + "drop_p": 0.5390563704010191, + "weight_decay": 0.0599829980648872, + "latent_dim": 28, + "beta_mi": 5.28601800227645, + "beta_tc": 0.11068120168249863, + "beta_dimKL": 0.1545831137755598, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 214, + "n_layers": 3, + "enc_factor": 1.1109543252183647, + "batch_size": 239, + "learning_rate": 0.0852413384541624, + "drop_p": 0.1393956681147261, + "weight_decay": 0.00027159304244348307, + "latent_dim": 55, + "beta_mi": 0.0014071348611466212, + "beta_tc": 901.8964204453516, + "beta_dimKL": 1.6269797824782968, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 161, + "n_layers": 3, + "enc_factor": 2.468801242230091, + "batch_size": 219, + "learning_rate": 0.008429628668381794, + "drop_p": 0.05975832437899407, + "weight_decay": 0.0013060799552731717, + "latent_dim": 53, + "beta_mi": 0.259300154137111, + "beta_tc": 0.34172718274327263, + "beta_dimKL": 0.11685664692961535, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + }, + { + "k_filter": 1134, + "n_layers": 3, + "enc_factor": 3.46286016127162, + "batch_size": 181, + "learning_rate": 0.0018692128886927716, + "drop_p": 0.7415813370780279, + "weight_decay": 0.015766852373720625, + "latent_dim": 27, + "beta_mi": 8.111242820802198, + "beta_tc": 0.5031554072157755, + "beta_dimKL": 3.2831678242761266, + "epochs": 10, + "checkpoint_interval": 10, + "loss_reduction": "sum" + } + ], + "25": [ + { + "k_filter": 206, + "n_layers": 2, + "enc_factor": 3.552104215130453, + "batch_size": 117, + "learning_rate": 2.9367894236331585e-05, + "drop_p": 0.4692521916057255, + "weight_decay": 0.00021224189037507733, + "latent_dim": 6, + "beta_mi": 0.015828773613432948, + "beta_tc": 0.20286384814308023, + "beta_dimKL": 0.01201462387156068, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 195, + "n_layers": 3, + "enc_factor": 2.644386601599408, + "batch_size": 93, + "learning_rate": 0.000800661214878037, + "drop_p": 0.15404961689348692, + "weight_decay": 1.6522540611157567e-05, + "latent_dim": 16, + "beta_mi": 0.007175337369232985, + "beta_tc": 0.4969844892356322, + "beta_dimKL": 2.0745134825831157, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 4095, + "n_layers": 2, + "enc_factor": 3.286288063064821, + "batch_size": 65, + "learning_rate": 2.6306720604634745e-05, + "drop_p": 0.8384544314062939, + "weight_decay": 0.0031488296844268213, + "latent_dim": 44, + "beta_mi": 0.004298740721808576, + "beta_tc": 3.8732253341498852, + "beta_dimKL": 0.0015276994519542557, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 186, + "n_layers": 2, + "enc_factor": 3.956596425991332, + "batch_size": 55, + "learning_rate": 0.000794187262762233, + "drop_p": 0.25533346477218705, + "weight_decay": 1.0260560286909748e-05, + "latent_dim": 37, + "beta_mi": 1.324036722301343, + "beta_tc": 3.816275631564879, + "beta_dimKL": 1.6756552564583793, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 305, + "n_layers": 3, + "enc_factor": 3.033219653078195, + "batch_size": 167, + "learning_rate": 0.0026729117581246334, + "drop_p": 0.09810954079200253, + "weight_decay": 7.682361044497475e-05, + "latent_dim": 39, + "beta_mi": 5.303463500740717, + "beta_tc": 962.7252676808939, + "beta_dimKL": 0.16416357186930675, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 270, + "n_layers": 3, + "enc_factor": 3.5370464054822106, + "batch_size": 98, + "learning_rate": 7.692135005317922e-05, + "drop_p": 0.6563968000487393, + "weight_decay": 0.0027312551962121495, + "latent_dim": 43, + "beta_mi": 0.009699856236433478, + "beta_tc": 327.0189190660576, + "beta_dimKL": 0.010739129186297778, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 244, + "n_layers": 3, + "enc_factor": 2.36512782830624, + "batch_size": 176, + "learning_rate": 0.005208389424591032, + "drop_p": 0.2152308057780925, + "weight_decay": 1.994191519376314e-05, + "latent_dim": 56, + "beta_mi": 0.024106700415390696, + "beta_tc": 8.462045621732042, + "beta_dimKL": 0.03182265228918236, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 3870, + "n_layers": 2, + "enc_factor": 3.419305610597936, + "batch_size": 163, + "learning_rate": 8.015685107287744e-05, + "drop_p": 0.8141965272512603, + "weight_decay": 2.6804755059545554e-05, + "latent_dim": 6, + "beta_mi": 0.14195866427893775, + "beta_tc": 57.39256058926011, + "beta_dimKL": 0.4986698112622851, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 1234, + "n_layers": 3, + "enc_factor": 1.8347727012932258, + "batch_size": 109, + "learning_rate": 0.00034478482791405307, + "drop_p": 0.051348676863122514, + "weight_decay": 6.0745421200148946e-05, + "latent_dim": 32, + "beta_mi": 0.6697161464917151, + "beta_tc": 0.2861402074115839, + "beta_dimKL": 0.7570253804464512, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + }, + { + "k_filter": 150, + "n_layers": 2, + "enc_factor": 1.5898651089289348, + "batch_size": 241, + "learning_rate": 0.0003480335273192267, + "drop_p": 0.41668532393917207, + "weight_decay": 1.5867997586190398e-05, + "latent_dim": 38, + "beta_mi": 3.7781413507585553, + "beta_tc": 13.306608711949787, + "beta_dimKL": 0.8551483948163392, + "epochs": 25, + "checkpoint_interval": 25, + "loss_reduction": "sum" + } + ], + "50": [ + { + "k_filter": 408, + "n_layers": 2, + "enc_factor": 1.8597185554776103, + "batch_size": 69, + "learning_rate": 0.0005624074090007561, + "drop_p": 0.04156623877695394, + "weight_decay": 0.0012664418497248752, + "latent_dim": 24, + "beta_mi": 0.5327566258489015, + "beta_tc": 49.69951672847248, + "beta_dimKL": 0.0957417304230493, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 207, + "n_layers": 2, + "enc_factor": 2.4434825257006483, + "batch_size": 105, + "learning_rate": 0.002509303182743217, + "drop_p": 0.29215724158871864, + "weight_decay": 4.010388557107498e-05, + "latent_dim": 26, + "beta_mi": 0.007177403790305613, + "beta_tc": 249.23633100133966, + "beta_dimKL": 0.03436358078305242, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 156, + "n_layers": 3, + "enc_factor": 2.18313120355463, + "batch_size": 139, + "learning_rate": 0.0001903529256401116, + "drop_p": 0.01852778464772027, + "weight_decay": 0.00013706189748968932, + "latent_dim": 40, + "beta_mi": 0.002353367364022855, + "beta_tc": 3.7705389875790534, + "beta_dimKL": 0.047827918782656534, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3473, + "n_layers": 3, + "enc_factor": 3.82719493479297, + "batch_size": 247, + "learning_rate": 0.030422431857532423, + "drop_p": 0.0005463606426775015, + "weight_decay": 0.01245738223571269, + "latent_dim": 8, + "beta_mi": 0.20833807414831018, + "beta_tc": 0.25858234096435545, + "beta_dimKL": 0.23581930198243134, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 151, + "n_layers": 4, + "enc_factor": 2.298937355985251, + "batch_size": 194, + "learning_rate": 0.0014435309684374474, + "drop_p": 0.04621214757746733, + "weight_decay": 0.005692094539242355, + "latent_dim": 24, + "beta_mi": 0.3335120981487652, + "beta_tc": 4.280900274598581, + "beta_dimKL": 0.0032359030544024748, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 1353, + "n_layers": 3, + "enc_factor": 1.90316772569139, + "batch_size": 76, + "learning_rate": 0.0025077251702660783, + "drop_p": 0.10822752373209298, + "weight_decay": 0.0033427087233004666, + "latent_dim": 33, + "beta_mi": 1.358066300198725, + "beta_tc": 14.962514874083213, + "beta_dimKL": 0.21026928898087918, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3736, + "n_layers": 3, + "enc_factor": 2.7672887242996795, + "batch_size": 90, + "learning_rate": 0.00039278127514855485, + "drop_p": 0.1873770714014374, + "weight_decay": 2.555284831871713e-05, + "latent_dim": 46, + "beta_mi": 0.041336126225396584, + "beta_tc": 20.01940273005834, + "beta_dimKL": 0.026326473968421794, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 198, + "n_layers": 3, + "enc_factor": 1.1320988889613677, + "batch_size": 38, + "learning_rate": 0.00023651505524454475, + "drop_p": 0.06510669359735971, + "weight_decay": 0.034774820761608156, + "latent_dim": 60, + "beta_mi": 0.34982835191919853, + "beta_tc": 28.84303602156435, + "beta_dimKL": 0.017199677681404055, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 175, + "n_layers": 3, + "enc_factor": 2.2856942824327247, + "batch_size": 40, + "learning_rate": 0.042026750298146315, + "drop_p": 0.6524860525002845, + "weight_decay": 0.015628582289502483, + "latent_dim": 62, + "beta_mi": 0.01773571590988453, + "beta_tc": 39.172410610347, + "beta_dimKL": 0.04144666468597043, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + }, + { + "k_filter": 3912, + "n_layers": 3, + "enc_factor": 2.5439553716353798, + "batch_size": 152, + "learning_rate": 0.0014276817263574344, + "drop_p": 0.8292351419003554, + "weight_decay": 0.02197084300392226, + "latent_dim": 8, + "beta_mi": 0.08153708019199478, + "beta_tc": 167.93345170569722, + "beta_dimKL": 0.1903098282451094, + "epochs": 50, + "checkpoint_interval": 50, + "loss_reduction": "sum" + } + ], + "100": [ + { + "k_filter": 180, + "n_layers": 4, + "enc_factor": 1.8393545995034741, + "batch_size": 166, + "learning_rate": 3.425559380476004e-05, + "drop_p": 0.4534629386516461, + "weight_decay": 0.05333378247857557, + "latent_dim": 30, + "beta_mi": 0.06272389528350991, + "beta_tc": 17.970208504767445, + "beta_dimKL": 0.0024978373410821713, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 206, + "n_layers": 4, + "enc_factor": 1.266173075609513, + "batch_size": 110, + "learning_rate": 0.00011138322003422999, + "drop_p": 0.21349023088552493, + "weight_decay": 0.004963921315164333, + "latent_dim": 48, + "beta_mi": 0.06530604787228304, + "beta_tc": 0.12288506860648053, + "beta_dimKL": 0.003674312400678291, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3419, + "n_layers": 2, + "enc_factor": 3.025741650471434, + "batch_size": 179, + "learning_rate": 0.06657596000737374, + "drop_p": 0.1772678880893595, + "weight_decay": 2.0625869770067743e-05, + "latent_dim": 7, + "beta_mi": 0.0047192946481027, + "beta_tc": 121.42076532002619, + "beta_dimKL": 0.00633557700194576, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3028, + "n_layers": 3, + "enc_factor": 3.521144269924054, + "batch_size": 184, + "learning_rate": 1.8461601024841578e-05, + "drop_p": 0.5602646337051272, + "weight_decay": 0.003196375397209935, + "latent_dim": 22, + "beta_mi": 1.11856445101648, + "beta_tc": 0.1287316493089083, + "beta_dimKL": 8.442165324186968, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 255, + "n_layers": 3, + "enc_factor": 2.4072411022480353, + "batch_size": 54, + "learning_rate": 0.0005778869089955389, + "drop_p": 0.31739625875121835, + "weight_decay": 0.0007186609620963752, + "latent_dim": 54, + "beta_mi": 0.001098785911104848, + "beta_tc": 113.74958644428786, + "beta_dimKL": 0.0520140610999868, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 1666, + "n_layers": 3, + "enc_factor": 1.0527980404520183, + "batch_size": 86, + "learning_rate": 0.00022170598981383362, + "drop_p": 0.5447060793128014, + "weight_decay": 6.12606051978882e-05, + "latent_dim": 15, + "beta_mi": 0.2965302151129267, + "beta_tc": 9.728377624297089, + "beta_dimKL": 0.20989808722580033, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 3851, + "n_layers": 3, + "enc_factor": 1.2795167807450327, + "batch_size": 139, + "learning_rate": 0.025899548761494404, + "drop_p": 0.7721059661773247, + "weight_decay": 0.00473280700585032, + "latent_dim": 20, + "beta_mi": 0.0010356926772253602, + "beta_tc": 0.5069458282844241, + "beta_dimKL": 0.0013851612116616324, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 133, + "n_layers": 3, + "enc_factor": 1.562665924233103, + "batch_size": 241, + "learning_rate": 0.00010201762064336695, + "drop_p": 0.021125887519177555, + "weight_decay": 0.039723220316364494, + "latent_dim": 33, + "beta_mi": 0.06444777757050936, + "beta_tc": 6.820748914848844, + "beta_dimKL": 0.003689800672072744, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 190, + "n_layers": 3, + "enc_factor": 3.3673329033914454, + "batch_size": 231, + "learning_rate": 0.012450210103424083, + "drop_p": 0.45354337815774187, + "weight_decay": 6.1002021965274905e-05, + "latent_dim": 32, + "beta_mi": 0.0015493628028589498, + "beta_tc": 3255.291238830594, + "beta_dimKL": 0.008031506009613934, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + }, + { + "k_filter": 350, + "n_layers": 2, + "enc_factor": 2.446232398589495, + "batch_size": 48, + "learning_rate": 0.010108466397969543, + "drop_p": 0.013329783102150716, + "weight_decay": 0.00032764307895219143, + "latent_dim": 43, + "beta_mi": 0.003971107178071414, + "beta_tc": 0.21503350616322, + "beta_dimKL": 0.02180903464825775, + "epochs": 100, + "checkpoint_interval": 100, + "loss_reduction": "sum" + } + ], + "150": [ + { + "k_filter": 403, + "n_layers": 2, + "enc_factor": 2.4642544609938595, + "batch_size": 114, + "learning_rate": 2.4215236610310955e-05, + "drop_p": 0.2906970562551173, + "weight_decay": 0.041601791844257885, + "latent_dim": 10, + "beta_mi": 3.7867775505382055, + "beta_tc": 152.7279882353313, + "beta_dimKL": 0.027767593562416013, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 209, + "n_layers": 3, + "enc_factor": 1.2121596911117087, + "batch_size": 173, + "learning_rate": 5.769348887137627e-05, + "drop_p": 0.18953096180267934, + "weight_decay": 8.123698667982872e-05, + "latent_dim": 21, + "beta_mi": 9.275812327027316, + "beta_tc": 1.7076929030562686, + "beta_dimKL": 0.01602275881103146, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 872, + "n_layers": 4, + "enc_factor": 2.448351404393532, + "batch_size": 159, + "learning_rate": 4.459813604527384e-05, + "drop_p": 0.5056092037756007, + "weight_decay": 5.3341124714831205e-05, + "latent_dim": 8, + "beta_mi": 0.14558730488190189, + "beta_tc": 4290.012992405537, + "beta_dimKL": 0.3185684315268731, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 243, + "n_layers": 4, + "enc_factor": 2.0093925647064284, + "batch_size": 69, + "learning_rate": 0.00012584969995726251, + "drop_p": 0.019768981805886997, + "weight_decay": 0.00017289562882219294, + "latent_dim": 39, + "beta_mi": 0.08481993887001389, + "beta_tc": 1.1551074198714957, + "beta_dimKL": 0.0026239181573311835, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 2627, + "n_layers": 3, + "enc_factor": 3.3280838181134333, + "batch_size": 246, + "learning_rate": 0.009737574223357229, + "drop_p": 0.2549366813588618, + "weight_decay": 0.06624874322113225, + "latent_dim": 19, + "beta_mi": 0.29255384727883466, + "beta_tc": 0.5107392868780007, + "beta_dimKL": 0.06870012558134155, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 336, + "n_layers": 2, + "enc_factor": 1.2450205973189363, + "batch_size": 54, + "learning_rate": 0.04434755181515611, + "drop_p": 0.7187047836879157, + "weight_decay": 0.006976476837383286, + "latent_dim": 11, + "beta_mi": 0.058600125666160685, + "beta_tc": 1215.1781605308745, + "beta_dimKL": 0.01433061396960466, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 133, + "n_layers": 3, + "enc_factor": 1.3107878108122248, + "batch_size": 119, + "learning_rate": 1.3365201891477669e-05, + "drop_p": 0.2023349783837657, + "weight_decay": 0.047071378263189, + "latent_dim": 17, + "beta_mi": 0.009391238429150106, + "beta_tc": 5.304418000905679, + "beta_dimKL": 0.011985477274799882, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 3147, + "n_layers": 3, + "enc_factor": 2.0110855420745146, + "batch_size": 98, + "learning_rate": 0.00021979103078524395, + "drop_p": 0.47659569988837613, + "weight_decay": 0.0008261899348417933, + "latent_dim": 32, + "beta_mi": 0.052410512882441265, + "beta_tc": 2.7527894519588623, + "beta_dimKL": 1.6279035676554643, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 158, + "n_layers": 2, + "enc_factor": 1.9042372647797587, + "batch_size": 138, + "learning_rate": 0.0004995984012614138, + "drop_p": 0.37277393808038356, + "weight_decay": 0.007141807887719299, + "latent_dim": 19, + "beta_mi": 0.10212366400663006, + "beta_tc": 0.27522825342562485, + "beta_dimKL": 0.0021301694074828794, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + }, + { + "k_filter": 724, + "n_layers": 2, + "enc_factor": 2.9158745679999845, + "batch_size": 200, + "learning_rate": 0.0005365974626707242, + "drop_p": 0.8994200941135204, + "weight_decay": 2.8289975213751478e-05, + "latent_dim": 39, + "beta_mi": 0.010542604412961468, + "beta_tc": 43.53747115951962, + "beta_dimKL": 0.26040621820439, + "epochs": 150, + "checkpoint_interval": 150, + "loss_reduction": "sum" + } + ], + "200": [ + { + "k_filter": 469, + "n_layers": 4, + "enc_factor": 2.449097041264312, + "batch_size": 234, + "learning_rate": 0.0002267213027440365, + "drop_p": 0.05827970879433773, + "weight_decay": 5.112448260196162e-05, + "latent_dim": 17, + "beta_mi": 8.026969102589458, + "beta_tc": 1.807107753854207, + "beta_dimKL": 0.3502452430160034, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 147, + "n_layers": 2, + "enc_factor": 3.089937291201452, + "batch_size": 178, + "learning_rate": 6.296993542524432e-05, + "drop_p": 0.43587637432854337, + "weight_decay": 0.003030011556747926, + "latent_dim": 36, + "beta_mi": 0.21186833847601094, + "beta_tc": 615.1383093522828, + "beta_dimKL": 0.07417607907648219, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 191, + "n_layers": 2, + "enc_factor": 1.1070674875662923, + "batch_size": 115, + "learning_rate": 0.00016601397720785398, + "drop_p": 0.3832899886403397, + "weight_decay": 0.010274883698934856, + "latent_dim": 58, + "beta_mi": 0.005004258752303177, + "beta_tc": 0.4068845593324205, + "beta_dimKL": 0.0030824065133634075, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2219, + "n_layers": 3, + "enc_factor": 2.7289135688162283, + "batch_size": 91, + "learning_rate": 0.0005282844979092852, + "drop_p": 0.2239709183588983, + "weight_decay": 0.09810411127978463, + "latent_dim": 34, + "beta_mi": 0.003925127586680921, + "beta_tc": 3.5735453937989585, + "beta_dimKL": 0.165855649893089, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2819, + "n_layers": 2, + "enc_factor": 3.26678682410136, + "batch_size": 150, + "learning_rate": 0.0013921875653076202, + "drop_p": 0.025275911420114493, + "weight_decay": 0.09158234241636762, + "latent_dim": 62, + "beta_mi": 0.10991761824823752, + "beta_tc": 5.3787721668384085, + "beta_dimKL": 5.022594324163146, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 418, + "n_layers": 3, + "enc_factor": 2.1476387316180507, + "batch_size": 47, + "learning_rate": 0.0013639261434035283, + "drop_p": 0.06306984263128576, + "weight_decay": 9.90546861057931e-05, + "latent_dim": 53, + "beta_mi": 0.12547618965824422, + "beta_tc": 103.68154830740545, + "beta_dimKL": 0.7894157710890353, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 227, + "n_layers": 3, + "enc_factor": 2.838087197437165, + "batch_size": 186, + "learning_rate": 0.035559270190409185, + "drop_p": 0.4951742616005214, + "weight_decay": 1.903859859946441e-05, + "latent_dim": 63, + "beta_mi": 0.29617629345170965, + "beta_tc": 0.721560069162139, + "beta_dimKL": 0.021290189534013564, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 2523, + "n_layers": 4, + "enc_factor": 3.0767221084861047, + "batch_size": 47, + "learning_rate": 0.00021626267661282005, + "drop_p": 0.3578393914158829, + "weight_decay": 0.00019168461014423049, + "latent_dim": 58, + "beta_mi": 0.0011696328069387698, + "beta_tc": 314.54356192493725, + "beta_dimKL": 0.01454426275364362, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 132, + "n_layers": 3, + "enc_factor": 3.4646462069825508, + "batch_size": 122, + "learning_rate": 8.469550309000637e-05, + "drop_p": 0.05116001213712014, + "weight_decay": 0.026876783396904608, + "latent_dim": 44, + "beta_mi": 0.003163217557987882, + "beta_tc": 5.7666434888694, + "beta_dimKL": 0.001322239713677116, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + }, + { + "k_filter": 1831, + "n_layers": 2, + "enc_factor": 3.869969671705331, + "batch_size": 217, + "learning_rate": 0.00047539939172167825, + "drop_p": 0.8574513074288412, + "weight_decay": 0.006594950239612749, + "latent_dim": 7, + "beta_mi": 0.18326530287037052, + "beta_tc": 0.417828646698006, + "beta_dimKL": 0.028139091499037698, + "epochs": 200, + "checkpoint_interval": 200, + "loss_reduction": "sum" + } + ], + "300": [ + { + "k_filter": 183, + "n_layers": 3, + "enc_factor": 2.371103982759999, + "batch_size": 180, + "learning_rate": 0.016800418273395692, + "drop_p": 0.7691792876209864, + "weight_decay": 0.06807211879514408, + "latent_dim": 25, + "beta_mi": 0.036144434264364526, + "beta_tc": 1.001930852371888, + "beta_dimKL": 1.9819983483341226, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 986, + "n_layers": 4, + "enc_factor": 2.6285614352183306, + "batch_size": 207, + "learning_rate": 0.03387966766699771, + "drop_p": 0.49804199260627957, + "weight_decay": 0.06322732299659689, + "latent_dim": 59, + "beta_mi": 0.014919111092748193, + "beta_tc": 3199.4773499539547, + "beta_dimKL": 0.002856901177663523, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 233, + "n_layers": 4, + "enc_factor": 1.1240840108800743, + "batch_size": 146, + "learning_rate": 0.00021810017494204567, + "drop_p": 0.5615171134759666, + "weight_decay": 0.0017593362195804135, + "latent_dim": 41, + "beta_mi": 0.0031068696313939046, + "beta_tc": 0.23738985994276887, + "beta_dimKL": 0.0028304307297869575, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 2045, + "n_layers": 2, + "enc_factor": 1.2454590793351512, + "batch_size": 192, + "learning_rate": 3.897320011182496e-05, + "drop_p": 0.64740628978351, + "weight_decay": 0.0008153004552797435, + "latent_dim": 48, + "beta_mi": 0.001329054383962461, + "beta_tc": 0.13314764688745395, + "beta_dimKL": 0.0068106804549574445, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 397, + "n_layers": 3, + "enc_factor": 1.7930340779963658, + "batch_size": 165, + "learning_rate": 0.05070022599853791, + "drop_p": 0.32755680034408075, + "weight_decay": 0.0001921142612723315, + "latent_dim": 12, + "beta_mi": 0.8118352256213575, + "beta_tc": 1.0527301499211914, + "beta_dimKL": 0.001635580904060032, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 166, + "n_layers": 3, + "enc_factor": 1.0000066086223087, + "batch_size": 188, + "learning_rate": 6.0805356995311484e-05, + "drop_p": 0.6880273384276123, + "weight_decay": 0.0019464206715977918, + "latent_dim": 41, + "beta_mi": 0.5379733177874212, + "beta_tc": 0.6921905567321784, + "beta_dimKL": 0.0014667503370090857, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 1304, + "n_layers": 3, + "enc_factor": 3.1500507449630324, + "batch_size": 163, + "learning_rate": 7.498077768250703e-05, + "drop_p": 0.3956463770713145, + "weight_decay": 3.769747232972353e-05, + "latent_dim": 28, + "beta_mi": 0.009066441718576635, + "beta_tc": 8.436516902457505, + "beta_dimKL": 1.2212423454816574, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 492, + "n_layers": 2, + "enc_factor": 2.614976730876814, + "batch_size": 192, + "learning_rate": 0.006824592488426886, + "drop_p": 0.3879908444029568, + "weight_decay": 0.00021668686084542755, + "latent_dim": 43, + "beta_mi": 0.014116571004934951, + "beta_tc": 0.38998320043206325, + "beta_dimKL": 0.012786095013825058, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 163, + "n_layers": 2, + "enc_factor": 2.1344556133559487, + "batch_size": 52, + "learning_rate": 0.0008735507031766657, + "drop_p": 0.04408226835813863, + "weight_decay": 0.0029625443885852826, + "latent_dim": 15, + "beta_mi": 0.03686080035328311, + "beta_tc": 0.3419762730839783, + "beta_dimKL": 0.0021120193408078274, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + }, + { + "k_filter": 339, + "n_layers": 3, + "enc_factor": 1.4880540199737493, + "batch_size": 199, + "learning_rate": 0.00023942655141519575, + "drop_p": 0.3585905111310979, + "weight_decay": 0.0002768761842511145, + "latent_dim": 33, + "beta_mi": 0.12400574341166024, + "beta_tc": 0.4391444473445687, + "beta_dimKL": 0.01733016881629241, + "epochs": 300, + "checkpoint_interval": 300, + "loss_reduction": "sum" + } + ] + } + } + } +} \ No newline at end of file diff --git a/tests/test_tuning/test_propose_initial_config.py b/tests/test_tuning/test_propose_initial_config.py new file mode 100644 index 00000000..7cf79dc4 --- /dev/null +++ b/tests/test_tuning/test_propose_initial_config.py @@ -0,0 +1,202 @@ +import subprocess +import sys +import warnings +from pathlib import Path + +import pytest +from pydantic import ValidationError + +from autoencodix.configs.disentanglix_config import DisentanglixConfig +from autoencodix.configs.ontix_config import OntixConfig +from autoencodix.configs.vanillix_config import VanillixConfig +from autoencodix.configs.varix_config import VarixConfig +from autoencodix.tuning import propose_initial_config +from autoencodix.tuning._propose import _load_artifact + +COVERED = { + "vanillix": VanillixConfig, + "varix": VarixConfig, + "ontix": OntixConfig, + "disentanglix": DisentanglixConfig, +} + + +def _bounds(cls, field_name): + """Read numeric ge/le constraints straight off the Pydantic field, rather + than hardcoding them in the test.""" + field = cls.model_fields[field_name] + ge = le = None + for meta in field.metadata: + if hasattr(meta, "ge"): + ge = meta.ge + if hasattr(meta, "le"): + le = meta.le + return ge, le + + +class TestProposeInitialConfigDefault: + @pytest.mark.parametrize("architecture,config_cls", COVERED.items()) + def test_default_downstream_combined(self, architecture, config_cls): + config = propose_initial_config(architecture) + assert isinstance(config, config_cls) + dumped = config.model_dump() + assert isinstance(dumped, dict) + assert dumped["epochs"] == 300 + + @pytest.mark.parametrize("architecture", COVERED) + def test_case_insensitive(self, architecture): + config = propose_initial_config(architecture.upper()) + assert isinstance(config, COVERED[architecture]) + + +class TestDatasetScoping: + def test_known_dataset_still_works(self): + artifact = _load_artifact() + datasets = [k for k in artifact["varix"] if k != "combined"] + assert datasets, "expected at least one non-combined dataset in the artifact" + config = propose_initial_config("varix", dataset=datasets[0]) + assert isinstance(config, VarixConfig) + + def test_unknown_dataset_raises(self): + with pytest.raises(ValueError): + propose_initial_config("varix", dataset="not_a_real_dataset") + + +class TestReconstructionObjective: + def test_default_budget_is_full_length(self): + config = propose_initial_config("varix", objective="reconstruction") + assert config.epochs == 300 + assert config.checkpoint_interval == 300 + + def test_low_budget_snaps_and_warns(self): + with pytest.warns(UserWarning): + config = propose_initial_config( + "varix", objective="reconstruction", budget_epochs=40 + ) + assert config.epochs == 50 + assert config.checkpoint_interval == 50 + + def test_exact_budget_no_warning(self): + with warnings.catch_warnings(): + warnings.simplefilter("error") + config = propose_initial_config( + "varix", objective="reconstruction", budget_epochs=300 + ) + assert config.epochs == 300 + + def test_reduced_budget_reduces_epochs(self): + config = propose_initial_config( + "varix", objective="reconstruction", budget_epochs=10 + ) + assert config.epochs == 10 + assert config.checkpoint_interval == 10 + + +class TestObjectiveValidation: + def test_downstream_with_budget_epochs_raises(self): + with pytest.raises(ValueError): + propose_initial_config("varix", objective="downstream", budget_epochs=25) + + def test_invalid_objective_raises(self): + with pytest.raises(ValueError): + propose_initial_config("varix", objective="not_a_real_objective") + + +class TestBoundsAndOverrides: + @pytest.mark.parametrize("architecture,config_cls", COVERED.items()) + def test_numeric_fields_within_schema_bounds(self, architecture, config_cls): + config = propose_initial_config(architecture) + for field_name in ("latent_dim", "n_layers", "batch_size", "learning_rate"): + if field_name not in config_cls.model_fields: + continue + ge, le = _bounds(config_cls, field_name) + value = getattr(config, field_name) + if ge is not None: + assert value >= ge + if le is not None: + assert value <= le + + def test_top_k_returns_multiple_distinct_configs(self): + configs = propose_initial_config("varix", top_k=3) + assert isinstance(configs, list) + assert len(configs) == 3 + dumps = [c.model_dump_json() for c in configs] + assert len(set(dumps)) > 1 + + def test_overrides_apply(self): + config = propose_initial_config("varix", latent_dim=7) + assert config.latent_dim == 7 + + def test_invalid_override_raises_validation_error(self): + with pytest.raises(ValidationError): + propose_initial_config("varix", latent_dim=-1) + + +class TestUnsupportedArchitecture: + def test_unsupported_architecture_raises_by_default(self): + with pytest.raises(ValueError): + propose_initial_config("stackix") + + def test_unsupported_architecture_falls_back_with_warning(self): + with pytest.warns(UserWarning): + config = propose_initial_config("stackix", allow_fallback_to_defaults=True) + from autoencodix.configs.stackix_config import StackixConfig + + assert isinstance(config, StackixConfig) + + def test_completely_unknown_architecture_raises_even_with_fallback(self): + with pytest.raises(ValueError): + propose_initial_config("not_a_real_architecture", allow_fallback_to_defaults=True) + + +@pytest.mark.slow +class TestPackagingSmokeTest: + def test_wheel_contains_data_and_is_importable(self, tmp_path): + repo_root = Path(__file__).resolve().parents[2] + dist_dir = tmp_path / "dist" + build = subprocess.run( + [sys.executable, "-m", "build", "--wheel", "--outdir", str(dist_dir)], + cwd=repo_root, + capture_output=True, + text=True, + ) + if build.returncode != 0: + pytest.skip(f"could not build wheel: {build.stderr[-2000:]}") + + wheels = list(dist_dir.glob("*.whl")) + assert wheels, "no wheel produced" + wheel_path = wheels[0] + + import zipfile + + with zipfile.ZipFile(wheel_path) as zf: + names = zf.namelist() + assert any( + name.endswith("autoencodix/tuning/data/initial_configs.json") + for name in names + ), f"initial_configs.json missing from wheel contents: {names}" + + venv_dir = tmp_path / "venv" + subprocess.run( + [sys.executable, "-m", "venv", str(venv_dir)], check=True + ) + venv_python = venv_dir / "bin" / "python" + install = subprocess.run( + [str(venv_python), "-m", "pip", "install", "--quiet", str(wheel_path)], + capture_output=True, + text=True, + ) + if install.returncode != 0: + pytest.skip(f"could not install wheel: {install.stderr[-2000:]}") + + check = subprocess.run( + [ + str(venv_python), + "-c", + "import autoencodix as acx; print(acx.propose_initial_config('varix').epochs)", + ], + capture_output=True, + text=True, + ) + assert check.returncode == 0, check.stderr + assert check.stdout.strip() == "300" From 82bf5eaf54c994f919e5878c8b68c97f9d8f0a88 Mon Sep 17 00:00:00 2001 From: kavlahkaff Date: Mon, 21 Sep 2026 10:26:20 +0200 Subject: [PATCH 2/2] remove stale benchmarking files --- benchmarking/tuning/README.md | 42 -- .../tuning/generate_initial_configs.py | 375 ------------------ 2 files changed, 417 deletions(-) delete mode 100644 benchmarking/tuning/README.md delete mode 100644 benchmarking/tuning/generate_initial_configs.py diff --git a/benchmarking/tuning/README.md b/benchmarking/tuning/README.md deleted file mode 100644 index cdce3b0e..00000000 --- a/benchmarking/tuning/README.md +++ /dev/null @@ -1,42 +0,0 @@ -# Initial-config generation report - -## vanillix - downstream: mean percentile 96.5 (n=7 held-out tasks) - reconstruction@10: mean percentile 68.0 (n=7 held-out tasks) - reconstruction@25: mean percentile 76.4 (n=7 held-out tasks) - reconstruction@50: mean percentile 63.8 (n=7 held-out tasks) - reconstruction@100: mean percentile 71.6 (n=7 held-out tasks) - reconstruction@150: mean percentile 61.5 (n=7 held-out tasks) - reconstruction@200: mean percentile 70.5 (n=7 held-out tasks) - reconstruction@300: mean percentile 76.5 (n=7 held-out tasks) - -## varix - downstream: mean percentile 72.8 (n=7 held-out tasks) - reconstruction@10: mean percentile 52.7 (n=7 held-out tasks) - reconstruction@25: mean percentile 71.2 (n=7 held-out tasks) - reconstruction@50: mean percentile 54.6 (n=7 held-out tasks) - reconstruction@100: mean percentile 55.4 (n=7 held-out tasks) - reconstruction@150: mean percentile 60.2 (n=7 held-out tasks) - reconstruction@200: mean percentile 57.5 (n=7 held-out tasks) - reconstruction@300: mean percentile 67.2 (n=7 held-out tasks) - -## ontix - downstream: mean percentile 62.8 (n=14 held-out tasks) - reconstruction@10: mean percentile 64.6 (n=14 held-out tasks) - reconstruction@25: mean percentile 55.4 (n=14 held-out tasks) - reconstruction@50: mean percentile 48.9 (n=14 held-out tasks) - reconstruction@100: mean percentile 50.6 (n=14 held-out tasks) - reconstruction@150: mean percentile 57.0 (n=14 held-out tasks) - reconstruction@200: mean percentile 50.2 (n=14 held-out tasks) - reconstruction@300: mean percentile 53.2 (n=14 held-out tasks) - -## disentanglix - downstream: mean percentile 62.0 (n=7 held-out tasks) - reconstruction@10: mean percentile 52.2 (n=7 held-out tasks) - reconstruction@25: mean percentile 71.5 (n=7 held-out tasks) - reconstruction@50: mean percentile 59.3 (n=7 held-out tasks) - reconstruction@100: mean percentile 68.0 (n=7 held-out tasks) - reconstruction@150: mean percentile 58.0 (n=7 held-out tasks) - reconstruction@200: mean percentile 47.6 (n=7 held-out tasks) - reconstruction@300: mean percentile 54.5 (n=7 held-out tasks) - diff --git a/benchmarking/tuning/generate_initial_configs.py b/benchmarking/tuning/generate_initial_configs.py deleted file mode 100644 index cdbfdfb6..00000000 --- a/benchmarking/tuning/generate_initial_configs.py +++ /dev/null @@ -1,375 +0,0 @@ -"""Offline generator for `src/autoencodix/tuning/data/initial_configs.json`. - -Dev-only script -- requires `syne-tune` (see the `dev` dependency group in -`pyproject.toml`). It is never imported by the shipped `autoencodix` package. - -It fits Syne Tune's `ZeroShotTransfer` scheduler against the BBOmix benchmark -blackbox data (105k autoencodix training runs) to produce a small ranked -portfolio of hyperparameter configs per (architecture, dataset-or-"combined", -objective[, budget]), and serializes the result to a static JSON artifact -shipped with the package. - -Generalization note: nothing here is specific to TCGA/SCHC. Each entry in -`BLACKBOX_MANIFEST` below just names one blackbox and which metric plays the -"downstream" role (an aggregate performance score, maximized, final epoch -only) versus the "reconstruction" role (minimized, per-epoch/multi-fidelity) -for that blackbox. Adding coverage for a brand new dataset means adding a -manifest entry pointing at that dataset's own blackbox and its own metric -names -- no other code in this script needs to change. - -Usage: - python benchmarking/tuning/generate_initial_configs.py -""" - -from __future__ import annotations - -import json -import logging -from pathlib import Path -from typing import Any, Dict, List, Optional - -import numpy as np -import pandas as pd -from syne_tune.blackbox_repository.blackbox_tabular import ( - BlackboxTabular, - deserialize as deserialize_tabular, -) -from syne_tune.blackbox_repository.repository import repository_path -from syne_tune.optimizer.schedulers.transfer_learning.transfer_learning_task_evaluation import ( - TransferLearningTaskEvaluations, -) -from syne_tune.config_space import Domain -from syne_tune.optimizer.schedulers.transfer_learning.zero_shot import ZeroShotTransfer - -logging.basicConfig(level=logging.INFO, format="%(message)s") -logger = logging.getLogger("generate_initial_configs") - - -def _patched_sample_random_config(self, config_space: Dict[str, Any]) -> Dict[str, Any]: - """Workaround for a bug in syne-tune==0.16.0's ZeroShotTransfer: it calls - `self.random_state` inside `_create_surrogate_transfer_learning_evaluations` - (triggered by `use_surrogates=True`), which runs *before* `self.random_state` - is ever assigned in `__init__`, raising AttributeError. This lazily creates - and caches the RandomState instead of relying on __init__ having set it. - Dev-only patch, applied only in this generation script -- never shipped.""" - rng = getattr(self, "random_state", None) - if rng is None: - rng = np.random.RandomState(getattr(self, "random_seed", None)) - self.random_state = rng - return { - k: v.sample(random_state=rng) if isinstance(v, Domain) else v - for k, v in config_space.items() - } - - -ZeroShotTransfer._sample_random_config = _patched_sample_random_config - -REPO_ROOT = Path(__file__).resolve().parents[2] -OUTPUT_PATH = REPO_ROOT / "src" / "autoencodix" / "tuning" / "data" / "initial_configs.json" -README_PATH = Path(__file__).resolve().parent / "README.md" - -BUDGET_GRID = [10, 25, 50, 100, 150, 200, 300] -TOP_K_STORED = 10 # ranked configs kept per portfolio leaf - -# Fixed values held constant during the BBOmix sweep (see the BBOmix archive's -# `autoencodix_package_bbomix/benchmarking/configs/search_space.yaml`), merged -# into every proposed config. -FIXED_HPS: Dict[str, Any] = { - "epochs": 300, - "checkpoint_interval": 300, - "loss_reduction": "sum", -} - -# HP fields the blackbox config space stores as Float (or that a surrogate -# candidate may sample as float) but the Config schema requires as int. -INT_FIELDS = ["n_layers", "batch_size", "latent_dim", "k_filter"] - -# --- manifest --------------------------------------------------------------- -# One entry per (architecture, dataset) blackbox usable as transfer-learning -# source data. This is the only place dataset-specific knowledge lives -- the -# rest of the script is generic over whatever is listed here. -BLACKBOX_MANIFEST: List[Dict[str, Any]] = [ - { - "blackbox_name": f"bbomix_{arch}_{dataset}", - "architecture": arch, - "dataset": dataset, - "downstream_metric": "metric_avg_ml_task_performance", - "reconstruction_metric": "metric_valid_recon_loss", - } - for arch in ("vanillix", "varix", "ontix", "disentanglix") - for dataset in ("tcga", "schc") -] - -_blackbox_cache: Dict[str, Dict[str, BlackboxTabular]] = {} - - -def _load_bbomix_blackbox(name: str) -> Dict[str, BlackboxTabular]: - """Load a locally-cached bbomix_* blackbox directly, bypassing Syne Tune's - registered-blackbox allowlist (bbomix blackboxes are BBOmix-specific, not - part of Syne Tune's own registry).""" - if name not in _blackbox_cache: - _blackbox_cache[name] = deserialize_tabular(repository_path / name) - return _blackbox_cache[name] - - -def _sanitize_hyperparameters(hp_df: pd.DataFrame) -> pd.DataFrame: - out = hp_df.copy() - for col in out.columns: - if pd.api.types.is_integer_dtype(out[col]): - out[col] = out[col].astype(int) - elif pd.api.types.is_float_dtype(out[col]): - out[col] = out[col].astype(float) - else: - out[col] = out[col].astype(str) - return out - - -def _task_evaluations( - bb: BlackboxTabular, metric: str, epoch_idx: Optional[int] -) -> Optional[TransferLearningTaskEvaluations]: - """Build a TransferLearningTaskEvaluations for one blackbox task, sliced at - `epoch_idx` (0-indexed) or the final epoch when `epoch_idx is None`.""" - try: - metric_index = bb.objectives_names.index(metric) - except ValueError: - return None - - evals = bb.objectives_evaluations # (H, S, E, O) - single = evals[..., metric_index : metric_index + 1] - if epoch_idx is None: - sliced = single[:, :, -1:, :] - else: - if epoch_idx >= single.shape[2]: - return None - sliced = single[:, :, epoch_idx : epoch_idx + 1, :] - - if np.all(np.isnan(sliced)): - return None - - return TransferLearningTaskEvaluations( - hyperparameters=_sanitize_hyperparameters(bb.hyperparameters), - configuration_space=bb.configuration_space, - objectives_evaluations=sliced, - objectives_names=[metric], - ) - - -def _build_transfer_evaluations( - entries: List[Dict[str, Any]], - metric_field: str, - epoch_idx: Optional[int] = None, - exclude_task_key: Optional[str] = None, -) -> Dict[str, TransferLearningTaskEvaluations]: - tle: Dict[str, TransferLearningTaskEvaluations] = {} - for entry in entries: - bb_dict = _load_bbomix_blackbox(entry["blackbox_name"]) - metric = entry[metric_field] - for task_name, bb in bb_dict.items(): - task_key = f"{entry['blackbox_name']}/{task_name}" - if task_key == exclude_task_key: - continue - task_eval = _task_evaluations(bb, metric, epoch_idx) - if task_eval is not None: - tle[task_key] = task_eval - return tle - - -def _fit_and_rank( - config_space: Dict[str, Any], - metric: str, - do_minimize: bool, - tle: Dict[str, TransferLearningTaskEvaluations], - num_configs: int = TOP_K_STORED, -) -> List[Dict[str, Any]]: - if not tle: - return [] - scheduler = ZeroShotTransfer( - config_space=config_space, - metric=metric, - do_minimize=do_minimize, - transfer_learning_evaluations=tle, - use_surrogates=True, - ) - configs: List[Dict[str, Any]] = [] - for _ in range(num_configs): - cfg = scheduler.get_config() - if cfg is None: - break - configs.append(dict(cfg)) - return configs - - -def _postprocess(hp: Dict[str, Any], epochs: int) -> Dict[str, Any]: - out = dict(hp) - for field in INT_FIELDS: - if field in out and out[field] is not None: - out[field] = int(round(out[field])) - out.update(FIXED_HPS) - if epochs < FIXED_HPS["epochs"]: - out["epochs"] = epochs - out["checkpoint_interval"] = epochs - return out - - -def _nearest_neighbor_percentile( - bb: BlackboxTabular, - metric: str, - epoch_idx: Optional[int], - do_minimize: bool, - hp: Dict[str, Any], -) -> Optional[float]: - """Approximate how good a recommended config is on a held-out task: find the - nearest real evaluated config (by normalized Euclidean distance in HP - space) and report what percentile of all real configs it beats. - - Informational only -- this is a nearest-neighbor proxy, not an exact - surrogate evaluation of the recommended config.""" - try: - metric_index = bb.objectives_names.index(metric) - except ValueError: - return None - - evals = bb.objectives_evaluations[..., metric_index] # (H, S, E) - idx = evals.shape[2] - 1 if epoch_idx is None else epoch_idx - if idx >= evals.shape[2]: - return None - scores = np.nanmean(evals[:, :, idx], axis=1) # (H,), averaged over seeds - valid = ~np.isnan(scores) - if valid.sum() == 0: - return None - - hp_df = bb.hyperparameters - columns = [c for c in hp_df.columns if c in hp] - if not columns: - return None - ranges = hp_df[columns].max() - hp_df[columns].min() - ranges = ranges.replace(0, 1.0) - norm_df = (hp_df[columns] - hp_df[columns].min()) / ranges - target = np.array([(hp[c] - hp_df[c].min()) / ranges[c] for c in columns]) - dists = np.linalg.norm(norm_df.values - target, axis=1) - dists = np.where(valid, dists, np.inf) - nn_idx = int(np.argmin(dists)) - nn_score = scores[nn_idx] - - valid_scores = scores[valid] - if do_minimize: - percentile = float((valid_scores >= nn_score).mean() * 100) - else: - percentile = float((valid_scores <= nn_score).mean() * 100) - return percentile - - -def _architectures() -> List[str]: - seen = [] - for entry in BLACKBOX_MANIFEST: - if entry["architecture"] not in seen: - seen.append(entry["architecture"]) - return seen - - -def _datasets_for(arch: str) -> List[str]: - return [e["dataset"] for e in BLACKBOX_MANIFEST if e["architecture"] == arch] - - -def run_validation(arch: str, report_lines: List[str]) -> None: - """Leave-one-task-out validation: for each held-out task, refit on the rest - and record the top-1 recommendation's nearest-neighbor percentile on the - held-out task. Informational only -- not asserted in CI.""" - entries = [e for e in BLACKBOX_MANIFEST if e["architecture"] == arch] - config_space = _load_bbomix_blackbox(entries[0]["blackbox_name"])[ - list(_load_bbomix_blackbox(entries[0]["blackbox_name"]))[0] - ].configuration_space - - objective_specs = [("downstream", "downstream_metric", None, False)] - for budget in BUDGET_GRID: - objective_specs.append( - (f"reconstruction@{budget}", "reconstruction_metric", budget - 1, True) - ) - - for label, metric_field, epoch_idx, do_minimize in objective_specs: - percentiles: List[float] = [] - for entry in entries: - bb_dict = _load_bbomix_blackbox(entry["blackbox_name"]) - metric = entry[metric_field] - for task_name, bb in bb_dict.items(): - task_key = f"{entry['blackbox_name']}/{task_name}" - tle = _build_transfer_evaluations( - entries, metric_field, epoch_idx, exclude_task_key=task_key - ) - top = _fit_and_rank( - config_space, metric, do_minimize, tle, num_configs=1 - ) - if not top: - continue - pct = _nearest_neighbor_percentile( - bb, metric, epoch_idx, do_minimize, top[0] - ) - if pct is not None: - percentiles.append(pct) - if percentiles: - msg = ( - f" {label}: mean percentile {np.mean(percentiles):.1f} " - f"(n={len(percentiles)} held-out tasks)" - ) - else: - msg = f" {label}: no held-out evaluations available" - logger.info(msg) - report_lines.append(msg) - - -def build_portfolios_for_architecture(arch: str) -> Dict[str, Any]: - entries = [e for e in BLACKBOX_MANIFEST if e["architecture"] == arch] - first_bb = _load_bbomix_blackbox(entries[0]["blackbox_name"]) - config_space = first_bb[list(first_bb)[0]].configuration_space - - result: Dict[str, Any] = {} - - def _downstream_portfolio(scoped_entries): - tle = _build_transfer_evaluations(scoped_entries, "downstream_metric") - raw = _fit_and_rank(config_space, "metric_avg_ml_task_performance", False, tle) - return [_postprocess(hp, epochs=FIXED_HPS["epochs"]) for hp in raw] - - def _reconstruction_portfolio(scoped_entries): - out = {} - for budget in BUDGET_GRID: - tle = _build_transfer_evaluations( - scoped_entries, "reconstruction_metric", epoch_idx=budget - 1 - ) - raw = _fit_and_rank(config_space, "metric_valid_recon_loss", True, tle) - out[str(budget)] = [_postprocess(hp, epochs=budget) for hp in raw] - return out - - result["combined"] = { - "downstream": _downstream_portfolio(entries), - "reconstruction": _reconstruction_portfolio(entries), - } - for dataset in _datasets_for(arch): - scoped = [e for e in entries if e["dataset"] == dataset] - result[dataset] = { - "downstream": _downstream_portfolio(scoped), - "reconstruction": _reconstruction_portfolio(scoped), - } - return result - - -def main() -> None: - report_lines = ["# Initial-config generation report", ""] - artifact: Dict[str, Any] = {} - - for arch in _architectures(): - logger.info("=== %s ===", arch) - report_lines.append(f"## {arch}") - run_validation(arch, report_lines) - artifact[arch] = build_portfolios_for_architecture(arch) - report_lines.append("") - - OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True) - OUTPUT_PATH.write_text(json.dumps(artifact, indent=2)) - logger.info("Wrote %s", OUTPUT_PATH) - - README_PATH.write_text("\n".join(report_lines) + "\n") - logger.info("Wrote %s", README_PATH) - - -if __name__ == "__main__": - main()