diff options
| -rw-r--r-- | TWO_STATE_BIAS_PROGRAM.md | 8 | ||||
| -rw-r--r-- | experiments/physical_bias_p1.py | 307 | ||||
| -rw-r--r-- | results/figs/physical_bias_p1_surrogate.png | bin | 0 -> 206126 bytes | |||
| -rw-r--r-- | results/figs/physical_bias_p1_surrogate_caption.md | 14 | ||||
| -rw-r--r-- | results/physical_bias/p1_surrogate.json | 2734 | ||||
| -rw-r--r-- | sdil/physical_coupled.py | 155 |
6 files changed, 3218 insertions, 0 deletions
diff --git a/TWO_STATE_BIAS_PROGRAM.md b/TWO_STATE_BIAS_PROGRAM.md index 1020b11..c7a238f 100644 --- a/TWO_STATE_BIAS_PROGRAM.md +++ b/TWO_STATE_BIAS_PROGRAM.md @@ -297,6 +297,14 @@ Stop this paper direction if: `30/50/80/100 mV` before the observed gate plateaus; see `results/physical_bias/p0_state_dependence.json`. This establishes a measured locally predictable component suitable for P1, not an SDIL learning result. +- Physical P1 measured-surrogate development: mixed. With the same upfront + neutral observations, frozen affine SDIL beats frozen constant calibration + at all seven switching periods and removes essentially the complete modeled + raw-to-oracle gap. Online constant recalibration also reaches the oracle but + uses `240--6000` further neutral observations. The ideal leading-order + overclamping analogue reaches zero error without neutral observations and + beats SDIL everywhere. Therefore the mechanism test passes, but the physical + strong-baseline gate does not; see `results/physical_bias/p1_surrogate.json`. - Dual Prop same-path confirmation: active/supporting, not a passed result. - EP/CpL adapters: not implemented under this bias model. - Current score for this new paper framing: 5/10 until P1 passes. diff --git a/experiments/physical_bias_p1.py b/experiments/physical_bias_p1.py new file mode 100644 index 0000000..9f605c2 --- /dev/null +++ b/experiments/physical_bias_p1.py @@ -0,0 +1,307 @@ +#!/usr/bin/env python3 +"""P1: test SDIL on the measured-state-dependent two-edge surrogate.""" + +from __future__ import annotations + +import argparse +import json +from pathlib import Path +import sys + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +import numpy as np + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT)) + +from sdil.physical_coupled import ( # noqa: E402 + Circuit, + LocalAffineBias, + LocalPredictor, + Task, + calibrate_predictor, + simulate_alternating_tasks, +) + + +METHODS = ( + "raw", + "same_rms_noise", + "frozen_constant", + "frozen_sdil", + "online_constant", + "overclamp", + "oracle", +) + +LABELS = { + "raw": "structured bias", + "same_rms_noise": "same-RMS noise", + "frozen_constant": "constant calibration", + "frozen_sdil": "SDIL", + "online_constant": "online recalibration", + "overclamp": "overclamp analogue", + "oracle": "oracle subtraction", +} + +COLORS = { + "raw": "#CC3311", + "same_rms_noise": "#BBBBBB", + "frozen_constant": "#EE7733", + "frozen_sdil": "#0077BB", + "online_constant": "#AA4499", + "overclamp": "#228833", + "oracle": "#000000", +} + + +def load_pair(source: dict, name: str, strength: float) -> dict: + record = source["pairs"][name] + reference = np.asarray(record["reference_gate"], dtype=float) + affine = record["local_affine_model"] + field = LocalAffineBias( + reference_gate=reference, + bias_at_reference=np.asarray( + affine["bias_at_reference_v_per_s"], dtype=float), + local_slopes=np.asarray(affine["local_slopes_per_s"], dtype=float), + ) + states = [] + for trace in record["traces"]: + states.append(np.column_stack(( + trace["retained_gate_minus"], trace["retained_gate_plus"]))) + states = np.vstack(states) + feature_scale = np.maximum(np.ptp(states, axis=0), 0.25) + circuit = Circuit() + beta_label = 0.14 if name == "experiment_1" else 0.18 + tasks = ( + Task("alpha", circuit.high, 0.31), + Task("beta", circuit.low, beta_label), + ) + measurement = lambda gates: field(gates, strength) # noqa: E731 + constant = LocalPredictor.zeros(reference, feature_scale, affine=False) + sdil = LocalPredictor.zeros(reference, feature_scale, affine=True) + calibration = { + "epochs": 30, + "learning_rate": 0.2, + "states": int(len(states)), + } + calibration["neutral_observations_each"] = calibrate_predictor( + constant, states, measurement, + epochs=calibration["epochs"], + learning_rate=calibration["learning_rate"], + ) + sdil_count = calibrate_predictor( + sdil, states, measurement, + epochs=calibration["epochs"], + learning_rate=calibration["learning_rate"], + ) + if sdil_count != calibration["neutral_observations_each"]: + raise AssertionError("calibration observation budgets disagree") + bias_samples = np.asarray([measurement(state) for state in states]) + calibration["constant_rmse"] = float(np.sqrt(np.mean([ + np.mean((measurement(state) - constant.predict(state)) ** 2) + for state in states + ]))) + calibration["sdil_rmse"] = float(np.sqrt(np.mean([ + np.mean((measurement(state) - sdil.predict(state)) ** 2) + for state in states + ]))) + calibration["constant_coefficients"] = constant.coefficients.tolist() + calibration["sdil_coefficients"] = sdil.coefficients.tolist() + return { + "field": field, + "states": states, + "circuit": circuit, + "tasks": tasks, + "constant": constant, + "sdil": sdil, + "noise_std": np.sqrt(np.mean(bias_samples * bias_samples, axis=0)), + "calibration": calibration, + } + + +def run_method( + pair: dict, + method: str, + period: float, + cycles: int, + initial_gates: np.ndarray, + strength: float, + seed: int, +) -> dict: + predictor = None + if method in {"frozen_constant", "online_constant"}: + predictor = pair["constant"] + elif method == "frozen_sdil": + predictor = pair["sdil"] + return simulate_alternating_tasks( + pair["circuit"], + pair["tasks"], + pair["field"], + method=method, + period_seconds=period, + cycles=cycles, + initial_gates=initial_gates, + bias_strength=strength, + predictor=predictor, + online_predictor_rate=0.05, + noise_standard_deviation=pair["noise_std"], + seed=seed, + ) + + +def plot_report(report: dict, output: Path) -> None: + fig, axes = plt.subplots(2, 2, figsize=(9.2, 7.0), sharex="col") + for column, name in enumerate(("experiment_1", "experiment_2")): + records = report["pairs"][name]["period_sweep"] + for method in METHODS: + selected = [record for record in records if record["method"] == method] + period = np.asarray([record["period_seconds"] for record in selected]) + error = np.asarray([record["mean_combined_error"] for record in selected]) + span = np.asarray([record["mean_cycle_span"] for record in selected]) + axes[0, column].loglog( + period, error, "o-", color=COLORS[method], + linewidth=1.3, markersize=3.5, label=LABELS[method]) + axes[1, column].loglog( + period, np.maximum(span, 1e-12), "o-", color=COLORS[method], + linewidth=1.3, markersize=3.5, label=LABELS[method]) + axes[0, column].set_title( + f"{chr(ord('A') + column)} {name.replace('_', ' ')}: error floor") + axes[0, column].set_ylabel("combined task error") + axes[1, column].set_title( + f"{chr(ord('C') + column)} {name.replace('_', ' ')}: cycle span") + axes[1, column].set_xlabel("task-switching period (s)") + axes[1, column].set_ylabel("gate-space cycle span (V)") + for row in range(2): + axes[row, column].grid(alpha=0.18) + axes[0, 0].legend(frameon=False, fontsize=7, ncol=2) + fig.suptitle( + "Measured-state-dependent two-edge surrogate: frozen local SDIL", + fontsize=11) + fig.tight_layout() + output.parent.mkdir(parents=True, exist_ok=True) + fig.savefig(output, dpi=180) + plt.close(fig) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser() + parser.add_argument( + "--state-dependence-json", type=Path, + default=Path("results/physical_bias/p0_state_dependence.json")) + parser.add_argument( + "--output", type=Path, + default=Path("results/physical_bias/p1_surrogate.json")) + parser.add_argument( + "--figure", type=Path, + default=Path("results/figs/physical_bias_p1_surrogate.png")) + parser.add_argument("--minimum-cycles", type=int, default=120) + parser.add_argument("--total-nominal-time", type=float, default=6.0) + parser.add_argument( + "--periods", type=float, nargs="+", + default=(0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.2)) + parser.add_argument("--bias-strength", type=float, default=1.0) + parser.add_argument("--seed", type=int, default=20260806) + return parser.parse_args() + + +def main() -> None: + args = parse_args() + source = json.loads(args.state_dependence_json.read_text()) + report = { + "analysis": "physical_measured_state_dependent_surrogate_p1", + "confirmatory": False, + "physical_hardware_demonstration": False, + "autodiff_used": False, + "source_analysis": str(args.state_dependence_json), + "protocol": { + "minimum_cycles": args.minimum_cycles, + "total_nominal_time_seconds": args.total_nominal_time, + "periods_seconds": args.periods, + "bias_strength": args.bias_strength, + "initial_gates": [4.0, 4.0], + "methods": METHODS, + "overclamp_scope": ( + "leading-order Appendix-F analogue; not the published classification endpoint" + ), + }, + "pairs": {}, + } + initial_gates = np.asarray(report["protocol"]["initial_gates"], dtype=float) + for pair_index, name in enumerate(("experiment_1", "experiment_2")): + pair = load_pair(source, name, args.bias_strength) + period_records = [] + for period in args.periods: + cycles = max( + args.minimum_cycles, + int(np.ceil(args.total_nominal_time / period)), + ) + for method_index, method in enumerate(METHODS): + period_records.append(run_method( + pair, method, period, cycles, initial_gates, + args.bias_strength, + args.seed + 1000 * pair_index + 10 * method_index, + )) + by_method = { + method: [record for record in period_records if record["method"] == method] + for method in METHODS + } + sdil_error = np.asarray([ + record["mean_combined_error"] for record in by_method["frozen_sdil"]]) + constant_error = np.asarray([ + record["mean_combined_error"] for record in by_method["frozen_constant"]]) + raw_error = np.asarray([ + record["mean_combined_error"] for record in by_method["raw"]]) + oracle_error = np.asarray([ + record["mean_combined_error"] for record in by_method["oracle"]]) + valid_gap = raw_error > oracle_error + 1e-16 + gap_closed = ( + (raw_error[valid_gap] - sdil_error[valid_gap]) + / (raw_error[valid_gap] - oracle_error[valid_gap]) + ) + overclamp_error = np.asarray([ + record["mean_combined_error"] for record in by_method["overclamp"]]) + report["pairs"][name] = { + "calibration": pair["calibration"], + "noise_standard_deviation_v_per_s": pair["noise_std"].tolist(), + "period_sweep": period_records, + "summary": { + "sdil_beats_frozen_constant_all_periods": bool(np.all( + sdil_error < constant_error)), + "median_raw_to_oracle_gap_closed_by_sdil": ( + None if len(gap_closed) == 0 else float(np.median(gap_closed))), + "overclamp_beats_sdil_all_periods": bool(np.all( + overclamp_error < sdil_error)), + "online_constant_neutral_observations_by_period": [ + int(record["neutral_observations_during_learning"]) + for record in by_method["online_constant"] + ], + "frozen_sdil_neutral_observations_by_period": [ + int(record["neutral_observations_during_learning"]) + for record in by_method["frozen_sdil"] + ], + }, + } + report["summary"] = { + "sdil_beats_frozen_constant_both_pairs": bool(all( + record["summary"]["sdil_beats_frozen_constant_all_periods"] + for record in report["pairs"].values() + )), + "median_gap_closed_by_pair": { + name: record["summary"]["median_raw_to_oracle_gap_closed_by_sdil"] + for name, record in report["pairs"].items() + }, + } + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(json.dumps(report, indent=2) + "\n") + plot_report(report, args.figure) + print(json.dumps(report["summary"], indent=2)) + print(f"wrote {args.output}") + print(f"wrote {args.figure}") + + +if __name__ == "__main__": + main() diff --git a/results/figs/physical_bias_p1_surrogate.png b/results/figs/physical_bias_p1_surrogate.png Binary files differnew file mode 100644 index 0000000..6888aa9 --- /dev/null +++ b/results/figs/physical_bias_p1_surrogate.png diff --git a/results/figs/physical_bias_p1_surrogate_caption.md b/results/figs/physical_bias_p1_surrogate_caption.md new file mode 100644 index 0000000..7174c0b --- /dev/null +++ b/results/figs/physical_bias_p1_surrogate_caption.md @@ -0,0 +1,14 @@ +**Development result on a measured-state-dependent two-edge surrogate.** A--B, +combined task error after matching at least 6 s of nominal training time across +switching periods. C--D, corresponding gate-space cycle span. The local affine +bias fields are inferred from the released Dillavou et al. drift traces; they +are not independent hardware measurements. Frozen constant calibration and +SDIL receive the same 660/2040 neutral observations in the two task pairs, +respectively, before learning. SDIL removes essentially the entire modeled +raw-to-oracle gap and beats frozen constant calibration at every period. A +constant estimator can also reach oracle performance when allowed another +240--6000 online neutral observations per run. Most importantly, the ideal +leading-order overclamping analogue reaches zero error without neutral +observations and beats SDIL throughout. Thus this result verifies the local +mechanism and observation tradeoff but does not pass the physical strong- +baseline gate or demonstrate correction on hardware. diff --git a/results/physical_bias/p1_surrogate.json b/results/physical_bias/p1_surrogate.json new file mode 100644 index 0000000..538aca1 --- /dev/null +++ b/results/physical_bias/p1_surrogate.json @@ -0,0 +1,2734 @@ +{ + "analysis": "physical_measured_state_dependent_surrogate_p1", + "confirmatory": false, + "physical_hardware_demonstration": false, + "autodiff_used": false, + "source_analysis": "results/physical_bias/p0_state_dependence.json", + "protocol": { + "minimum_cycles": 120, + "total_nominal_time_seconds": 6.0, + "periods_seconds": [ + 0.002, + 0.005, + 0.01, + 0.02, + 0.05, + 0.1, + 0.2 + ], + "bias_strength": 1.0, + "initial_gates": [ + 4.0, + 4.0 + ], + "methods": [ + "raw", + "same_rms_noise", + "frozen_constant", + "frozen_sdil", + "online_constant", + "overclamp", + "oracle" + ], + "overclamp_scope": "leading-order Appendix-F analogue; not the published classification endpoint" + }, + "pairs": { + "experiment_1": { + "calibration": { + "epochs": 30, + "learning_rate": 0.2, + "states": 22, + "neutral_observations_each": 660, + "constant_rmse": 0.6092862026373747, + "sdil_rmse": 0.00022387993784781475, + "constant_coefficients": [ + [ + 2.680657432007967 + ], + [ + 5.076732410928136 + ] + ], + "sdil_coefficients": [ + [ + 2.6533297670019302, + 1.8846356629906003 + ], + [ + 4.543569954617925, + 1.2256020448180966 + ] + ] + }, + "noise_standard_deviation_v_per_s": [ + 3.069815200619905, + 4.678340465344394 + ], + "period_sweep": [ + { + "method": "raw", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.8092950610197422, + 2.7801625927089715 + ], + "bias_strength": 1.0, + "mean_combined_error": 0.00010132868475959094, + "std_combined_error": 1.3552527156068805e-20, + "mean_cycle_span": 0.012124201610815623, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4348008741467715, + 2.3914423248582395 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.8492752386031335e-08, + "std_combined_error": 2.8226404709445005e-08, + "mean_cycle_span": 0.001980552372751122, + "std_cycle_span": 0.0010148528512669655, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.3483393122116025, + 2.296572194967358 + ], + "bias_strength": 1.0, + "mean_combined_error": 7.153264153456787e-06, + "std_combined_error": 8.470329472543003e-22, + "mean_cycle_span": 0.0032048623473235746, + "std_cycle_span": 4.336808689942018e-19, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.680657432007967 + ], + [ + 5.076732410928136 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314547564137823, + 2.387155458484078 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.357314677519754e-12, + "std_combined_error": 0.0, + "mean_cycle_span": 1.3508054197714377e-06, + "std_cycle_span": 2.117582368135751e-22, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.6533297670019302, + 1.8846356629906003 + ], + [ + 4.543569954617925, + 1.2256020448180966 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892734493, + 2.387197231833999 + ], + "bias_strength": 1.0, + "mean_combined_error": 7.140770454804554e-30, + "std_combined_error": 0.0, + "mean_cycle_span": 3.1401849173675502e-15, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 6000, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.1636571024018956 + ], + [ + 3.844278964067793 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892733636, + 2.3871972318339174 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.274080905458301e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.031753401590313146, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892734493, + 2.387197231833999 + ], + "bias_strength": 1.0, + "mean_combined_error": 7.140770454804554e-30, + "std_combined_error": 0.0, + "mean_cycle_span": 3.1401849173675502e-15, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.8157189778542713, + 2.7745905776153856 + ], + "bias_strength": 1.0, + "mean_combined_error": 0.00010199355355150576, + "std_combined_error": 1.3552527156068805e-20, + "mean_cycle_span": 0.029105116820791088, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.443926854020796, + 2.4076596115844797 + ], + "bias_strength": 1.0, + "mean_combined_error": 2.4181655343656334e-07, + "std_combined_error": 7.224475537035746e-08, + "mean_cycle_span": 0.0027930688106144923, + "std_cycle_span": 0.0012869103694595587, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.346707000455192, + 2.2981034295135827 + ], + "bias_strength": 1.0, + "mean_combined_error": 7.214734003252294e-06, + "std_combined_error": 8.470329472543003e-22, + "mean_cycle_span": 0.007692475077109321, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.680657432007967 + ], + [ + 5.076732410928136 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431454123493791, + 2.387156147013957 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.3673238256676707e-12, + "std_combined_error": 2.0194839173657902e-28, + "mean_cycle_span": 3.2419331160020885e-06, + "std_cycle_span": 4.235164736271502e-22, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.6533297670019302, + 1.8846356629906003 + ], + [ + 4.543569954617925, + 1.2256020448180966 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431487889273448, + 2.3871972318339947 + ], + "bias_strength": 1.0, + "mean_combined_error": 6.61942121885893e-30, + "std_combined_error": 0.0, + "mean_cycle_span": 7.536443801682121e-15, + "std_cycle_span": 1.5777218104420236e-30, + "neutral_observations_during_learning": 2400, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.163657102401891 + ], + [ + 3.8442789640677892 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431487889273364, + 2.3871972318339174 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.274080905458301e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.03175469628805606, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431487889273448, + 2.3871972318339947 + ], + "bias_strength": 1.0, + "mean_combined_error": 6.61942121885893e-30, + "std_combined_error": 0.0, + "mean_cycle_span": 7.536443801682121e-15, + "std_cycle_span": 1.5777218104420236e-30, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.829137596724204, + 2.765695325601806 + ], + "bias_strength": 1.0, + "mean_combined_error": 0.00010468365735072873, + "std_combined_error": 1.3552527156068805e-20, + "mean_cycle_span": 0.06069482777522618, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4348145889966357, + 2.3907868242683947 + ], + "bias_strength": 1.0, + "mean_combined_error": 8.028745097576818e-08, + "std_combined_error": 6.12766613433568e-08, + "mean_cycle_span": 0.004359354310386148, + "std_cycle_span": 0.002949089530150418, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.3433128217321104, + 2.3005860749982743 + ], + "bias_strength": 1.0, + "mean_combined_error": 7.463848041630655e-06, + "std_combined_error": 0.0, + "mean_cycle_span": 0.016032761228693466, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.680657432007967 + ], + [ + 5.076732410928136 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.43145280599553, + 2.3871572783847346 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.4078218456206076e-12, + "std_combined_error": 0.0, + "mean_cycle_span": 6.754028213225775e-06, + "std_cycle_span": 8.470329472543003e-22, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.6533297670019302, + 1.8846356629906003 + ], + [ + 4.543569954617925, + 1.2256020448180966 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892733254, + 2.387197231833879 + ], + "bias_strength": 1.0, + "mean_combined_error": 8.397054557528348e-31, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 1200, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.1636571024017908 + ], + [ + 3.8442789640677173 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892733636, + 2.3871972318339174 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.274080905458301e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.03175859291984668, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892733875, + 2.3871972318339405 + ], + "bias_strength": 1.0, + "mean_combined_error": 7.888609052210118e-31, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.86041773979248, + 2.7537847011829983 + ], + "bias_strength": 1.0, + "mean_combined_error": 0.00011521059490045322, + "std_combined_error": 1.3552527156068805e-20, + "mean_cycle_span": 0.12184926735735116, + "std_cycle_span": 1.3877787807814457e-17, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.43486212016216, + 2.390381459087656 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.7506885005100094e-07, + "std_combined_error": 1.3600797927093883e-07, + "mean_cycle_span": 0.006769875807616741, + "std_cycle_span": 0.0034511326501450923, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.335463918674156, + 2.3040622548784158 + ], + "bias_strength": 1.0, + "mean_combined_error": 8.444831514408495e-06, + "std_combined_error": 0.0, + "mean_cycle_span": 0.03211797946499549, + "std_cycle_span": 6.938893903907228e-18, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.680657432007967 + ], + [ + 5.076732410928136 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431449760564751, + 2.387158923466784 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.5663008198711989e-12, + "std_combined_error": 2.0194839173657902e-28, + "mean_cycle_span": 1.3508063288864665e-05, + "std_cycle_span": 3.3881317890172014e-21, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.6533297670019302, + 1.8846356629906003 + ], + [ + 4.543569954617925, + 1.2256020448180966 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431487889273368, + 2.3871972318338974 + ], + "bias_strength": 1.0, + "mean_combined_error": 8.829618423037722e-31, + "std_combined_error": 6.368804265876902e-32, + "mean_cycle_span": 8.881784197001253e-17, + "std_cycle_span": 3.8714799753065e-16, + "neutral_observations_during_learning": 600, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.163657102401808 + ], + [ + 3.844278964067742 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431487889273363, + 2.3871972318339174 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.274080905458301e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.03176676920855227, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892733875, + 2.3871972318339405 + ], + "bias_strength": 1.0, + "mean_combined_error": 7.888609052210118e-31, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.997349031378711, + 2.7560615550386856 + ], + "bias_strength": 1.0, + "mean_combined_error": 0.00019054762008641855, + "std_combined_error": 9.244675222610997e-16, + "mean_cycle_span": 0.3125016255415446, + "std_cycle_span": 8.400902749285477e-13, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.437208185576708, + 2.39142169352168 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.9515584814923498e-07, + "std_combined_error": 1.7634282210639652e-07, + "mean_cycle_span": 0.010388750288987723, + "std_cycle_span": 0.005462496446466231, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.3018625017984506, + 2.3049553752688 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.573409373032438e-05, + "std_combined_error": 0.0, + "mean_cycle_span": 0.08117759729854893, + "std_cycle_span": 1.3877787807814457e-17, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.680657432007967 + ], + [ + 5.076732410928136 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431436893766853, + 2.3871599934589325 + ], + "bias_strength": 1.0, + "mean_combined_error": 2.69962879231075e-12, + "std_combined_error": 4.0389678347315804e-28, + "mean_cycle_span": 3.377027255632158e-05, + "std_cycle_span": 6.776263578034403e-21, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.6533297670019302, + 1.8846356629906003 + ], + [ + 4.543569954617925, + 1.2256020448180966 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431487614311821, + 2.3871970285098962 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.69473107681078e-15, + "std_combined_error": 1.9675422661411047e-15, + "mean_cycle_span": 7.375974614382561e-07, + "std_cycle_span": 4.723544418725612e-07, + "neutral_observations_during_learning": 240, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.163656688805505 + ], + [ + 3.8442822176345444 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431487889273363, + 2.3871972318339174 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.274080905458301e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.03177473827091023, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892733875, + 2.3871972318339405 + ], + "bias_strength": 1.0, + "mean_combined_error": 7.888609052210118e-31, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 3.364095082798542, + 2.863858140999168 + ], + "bias_strength": 1.0, + "mean_combined_error": 0.00047738371762902387, + "std_combined_error": 5.421010862427522e-20, + "mean_cycle_span": 0.678341055788438, + "std_cycle_span": 1.1102230246251565e-16, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.415853646830911, + 2.383944446107968 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.284170183249626e-07, + "std_combined_error": 3.663912605977088e-07, + "mean_cycle_span": 0.01645254240734324, + "std_cycle_span": 0.006714250532846139, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.217657716584461, + 2.2817475250102337 + ], + "bias_strength": 1.0, + "mean_combined_error": 4.6960587863687746e-05, + "std_combined_error": 6.776263578034403e-21, + "mean_cycle_span": 0.16783822717153069, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.680657432007967 + ], + [ + 5.076732410928136 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314062868891466, + 2.387152306257588 + ], + "bias_strength": 1.0, + "mean_combined_error": 6.962180538140995e-12, + "std_combined_error": 0.0, + "mean_cycle_span": 6.754123450716741e-05, + "std_cycle_span": 1.3552527156068805e-20, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.6533297670019302, + 1.8846356629906003 + ], + [ + 4.543569954617925, + 1.2256020448180966 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431487732570713, + 2.387197118645531 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.0402571186271138e-15, + "std_combined_error": 1.2382518634320076e-15, + "mean_cycle_span": 7.024009057970519e-07, + "std_cycle_span": 4.631954102213817e-07, + "neutral_observations_during_learning": 240, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.1636558358249895 + ], + [ + 3.844281524644432 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892733636, + 2.3871972318339174 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.274080905458301e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.03177520231889655, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892733875, + 2.3871972318339405 + ], + "bias_strength": 1.0, + "mean_combined_error": 7.888609052210118e-31, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 4.690236335935761, + 3.3986961942246574 + ], + "bias_strength": 1.0, + "mean_combined_error": 0.0018000468460461258, + "std_combined_error": 6.268050226983288e-17, + "mean_cycle_span": 1.78741571052108, + "std_cycle_span": 4.8714886040487515e-14, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.452310046781332, + 2.3945189106070064 + ], + "bias_strength": 1.0, + "mean_combined_error": 6.453687156062093e-07, + "std_combined_error": 6.680922284342304e-07, + "mean_cycle_span": 0.0249177070035543, + "std_cycle_span": 0.011391443518562177, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 1.9862402321993025, + 2.190959339656071 + ], + "bias_strength": 1.0, + "mean_combined_error": 0.0002306141403267977, + "std_combined_error": 2.710505431213761e-20, + "mean_cycle_span": 0.36609667263607126, + "std_cycle_span": 5.551115123125783e-17, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.680657432007967 + ], + [ + 5.076732410928136 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.431331914351697, + 2.3871234133188963 + ], + "bias_strength": 1.0, + "mean_combined_error": 2.483834916974681e-11, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0001350861087249672, + "std_cycle_span": 2.710505431213761e-20, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.6533297670019302, + 1.8846356629906003 + ], + [ + 4.543569954617925, + 1.2256020448180966 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314879320244738, + 2.387197210808737 + ], + "bias_strength": 1.0, + "mean_combined_error": 2.255565466427137e-16, + "std_combined_error": 2.5702906872208766e-16, + "mean_cycle_span": 4.1624257419200855e-07, + "std_cycle_span": 2.5507665702156565e-07, + "neutral_observations_during_learning": 240, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + 2.1636552501266073 + ], + [ + 3.8442809550164565 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892733636, + 2.3871972318339174 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.274080905458301e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.03177520526850427, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.4314878892733875, + 2.3871972318339405 + ], + "bias_strength": 1.0, + "mean_combined_error": 7.888609052210118e-31, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": null + } + ], + "summary": { + "sdil_beats_frozen_constant_all_periods": true, + "median_raw_to_oracle_gap_closed_by_sdil": 0.9999999864048891, + "overclamp_beats_sdil_all_periods": true, + "online_constant_neutral_observations_by_period": [ + 6000, + 2400, + 1200, + 600, + 240, + 240, + 240 + ], + "frozen_sdil_neutral_observations_by_period": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "experiment_2": { + "calibration": { + "epochs": 30, + "learning_rate": 0.2, + "states": 68, + "neutral_observations_each": 2040, + "constant_rmse": 0.3335551554014055, + "sdil_rmse": 2.192388102797653e-06, + "constant_coefficients": [ + [ + -0.33502087152139154 + ], + [ + 1.996528756755168 + ] + ], + "sdil_coefficients": [ + [ + -0.2839866529869272, + 1.4140559020638932 + ], + [ + 2.0992982944920144, + -0.1862355096516429 + ] + ] + }, + "noise_standard_deviation_v_per_s": [ + 0.4218300293576763, + 2.0616027304234703 + ], + "period_sweep": [ + { + "method": "raw", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 3.176531959717122, + 3.9390092336660687 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.957371367511765e-05, + "std_combined_error": 2.767656425223995e-15, + "mean_cycle_span": 0.005070816704448247, + "std_cycle_span": 4.1053612840121085e-13, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.966230900449063, + 3.6329395631130024 + ], + "bias_strength": 1.0, + "mean_combined_error": 2.309315045502897e-09, + "std_combined_error": 1.6826583274247304e-09, + "mean_cycle_span": 0.0006750258186158052, + "std_cycle_span": 0.0006049739423524212, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.979065145785647, + 3.654103430880535 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.3538567866487397e-07, + "std_combined_error": 5.762675161018651e-18, + "mean_cycle_span": 0.0004005873201374974, + "std_cycle_span": 1.0896774870155784e-14, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.33502087152139154 + ], + [ + 1.996528756755168 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533383368455, + 3.6303166883990974 + ], + "bias_strength": 1.0, + "mean_combined_error": 9.628573830176422e-19, + "std_combined_error": 2.2483300014744642e-24, + "mean_cycle_span": 1.1520884141532123e-09, + "std_cycle_span": 1.486414608333225e-15, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.2839866529869272, + 1.4140559020638932 + ], + [ + 2.0992982944920144, + -0.1862355096516429 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936661133, + 3.630316742082591 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.931269832241446e-28, + "std_combined_error": 4.197039051139412e-29, + "mean_cycle_span": 2.52478247881128e-14, + "std_cycle_span": 1.1733564156075178e-15, + "neutral_observations_during_learning": 6000, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.4096138759565473 + ], + [ + 2.213187313789102 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936651647, + 3.630316742081457 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.5792625543975334e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.01413443259744131, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.002, + "cycles": 3000, + "half_steps": 5, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.964253393666265, + 3.630316742082775 + ], + "bias_strength": 1.0, + "mean_combined_error": 5.262216557415797e-28, + "std_combined_error": 5.594464262246296e-29, + "mean_cycle_span": 2.922397051978476e-14, + "std_cycle_span": 1.610423795018914e-15, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 3.1792619353532885, + 3.936756053914711 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.9646470671690832e-05, + "std_combined_error": 1.6888927163362493e-14, + "mean_cycle_span": 0.012171175618583796, + "std_cycle_span": 5.989147116649013e-12, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9700354721887097, + 3.6370679415086054 + ], + "bias_strength": 1.0, + "mean_combined_error": 2.4462136678271593e-08, + "std_combined_error": 8.309248298984371e-09, + "mean_cycle_span": 0.001582775700256443, + "std_cycle_span": 0.0008049379867913901, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9792691518821868, + 3.6539143712803246 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.3588613108188043e-07, + "std_combined_error": 4.350849321850363e-17, + "mean_cycle_span": 0.0009614752233830148, + "std_cycle_span": 1.972728586978365e-13, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.33502087152139154 + ], + [ + 1.996528756755168 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533376238918, + 3.630316688802258 + ], + "bias_strength": 1.0, + "mean_combined_error": 9.669779508030872e-19, + "std_combined_error": 1.856395820837115e-23, + "mean_cycle_span": 2.7648542667100643e-09, + "std_cycle_span": 2.7958509530774352e-14, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.2839866529869272, + 1.4140559020638932 + ], + [ + 2.0992982944920144, + -0.1862355096516429 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.964253393667424, + 3.630316742084126 + ], + "bias_strength": 1.0, + "mean_combined_error": 2.89364054277892e-27, + "std_combined_error": 7.369116159769359e-28, + "mean_cycle_span": 1.6343894148704521e-13, + "std_cycle_span": 2.094557663874815e-14, + "neutral_observations_during_learning": 2400, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.40961387595487614 + ], + [ + 2.2131873137887244 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936651647, + 3.630316742081457 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.5792625543975334e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.01398740069769411, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.005, + "cycles": 1200, + "half_steps": 12, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936685473, + 3.6303167420854257 + ], + "bias_strength": 1.0, + "mean_combined_error": 6.367176174770757e-27, + "std_combined_error": 1.5925201331071837e-27, + "mean_cycle_span": 2.416855484135761e-13, + "std_cycle_span": 3.0289709200763395e-14, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 5.7600000000033065, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 3.1848610835073123, + 3.933175774521425 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.9940803657707882e-05, + "std_combined_error": 1.969022990071133e-14, + "mean_cycle_span": 0.025366845329081584, + "std_cycle_span": 1.432983327119186e-11, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9662902295955997, + 3.6327888368612915 + ], + "bias_strength": 1.0, + "mean_combined_error": 5.422781795471078e-09, + "std_combined_error": 4.521418008163007e-09, + "mean_cycle_span": 0.0017510872536162798, + "std_cycle_span": 0.000908326551390631, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9796882348645752, + 3.6536091927695766 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.3791142522237858e-07, + "std_combined_error": 4.5378679236239257e-17, + "mean_cycle_span": 0.002003625870996928, + "std_cycle_span": 4.2131266342481465e-13, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.33502087152139154 + ], + [ + 1.996528756755168 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533361817702, + 3.6303166894187515 + ], + "bias_strength": 1.0, + "mean_combined_error": 9.841438267223092e-19, + "std_combined_error": 1.820369867746918e-23, + "mean_cycle_span": 5.76035992722468e-09, + "std_cycle_span": 5.644789281414016e-14, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.2839866529869272, + 1.4140559020638932 + ], + [ + 2.0992982944920144, + -0.1862355096516429 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936655098, + 3.6303167420818547 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.2621972854320462e-28, + "std_combined_error": 6.715716366905685e-29, + "mean_cycle_span": 6.882162419836761e-14, + "std_cycle_span": 1.8664261041976768e-14, + "neutral_observations_during_learning": 1200, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.40961387595692217 + ], + [ + 2.2131873137891827 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936651647, + 3.630316742081457 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.5792625543975334e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.013987476025233779, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.01, + "cycles": 600, + "half_steps": 25, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.964253393666416, + 3.6303167420828686 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.4843898779267577e-27, + "std_combined_error": 7.561051799375225e-28, + "mean_cycle_span": 2.352362569495467e-13, + "std_cycle_span": 6.119277922394014e-14, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 3.1975697969457184, + 3.928478949922958 + ], + "bias_strength": 1.0, + "mean_combined_error": 2.1091928677703137e-05, + "std_combined_error": 7.408420918385458e-14, + "mean_cycle_span": 0.05081326173431949, + "std_cycle_span": 1.0189414300386609e-10, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.966382328890066, + 3.6327744115680476 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.620024496179272e-08, + "std_combined_error": 1.546368000002186e-08, + "mean_cycle_span": 0.0024337779581857124, + "std_cycle_span": 0.0012269652618947826, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9806413447254876, + 3.6531888857104304 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.458437241513648e-07, + "std_combined_error": 2.054432720285989e-16, + "mean_cycle_span": 0.004011547784602845, + "std_cycle_span": 3.565009874503914e-12, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.33502087152139154 + ], + [ + 1.996528756755168 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533330081595, + 3.6303166901572124 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.0508008569722728e-18, + "std_combined_error": 8.687113950617191e-23, + "mean_cycle_span": 1.1520155201956403e-08, + "std_cycle_span": 5.016834562953646e-13, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.2839866529869272, + 1.4140559020638932 + ], + [ + 2.0992982944920144, + -0.1862355096516429 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936655973, + 3.630316742081905 + ], + "bias_strength": 1.0, + "mean_combined_error": 4.922919219840778e-28, + "std_combined_error": 4.272260719650653e-28, + "mean_cycle_span": 2.4006870467148263e-13, + "std_cycle_span": 1.0959565513441156e-13, + "neutral_observations_during_learning": 600, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.4096138759572491 + ], + [ + 2.2131873137892812 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936651647, + 3.630316742081457 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.5792625543975334e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.01398797679940297, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.02, + "cycles": 300, + "half_steps": 50, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936669624, + 3.6303167420833438 + ], + "bias_strength": 1.0, + "mean_combined_error": 9.871444814590853e-27, + "std_combined_error": 9.299414080521215e-27, + "mean_cycle_span": 1.0836956880419996e-12, + "std_cycle_span": 5.450016010478752e-13, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 3.250950849312841, + 3.9310464437485537 + ], + "bias_strength": 1.0, + "mean_combined_error": 2.93110837511962e-05, + "std_combined_error": 3.0687604349048204e-12, + "mean_cycle_span": 0.12840654696041115, + "std_cycle_span": 7.615564138367519e-09, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.966860681643815, + 3.632687706921391 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.5137351959154617e-08, + "std_combined_error": 1.3223270145000082e-08, + "mean_cycle_span": 0.003492894585600989, + "std_cycle_span": 0.0017844315068364142, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9846492965900473, + 3.6531987886779493 + ], + "bias_strength": 1.0, + "mean_combined_error": 2.029886103778275e-07, + "std_combined_error": 1.970328054838896e-14, + "mean_cycle_span": 0.010102835203733236, + "std_cycle_span": 5.825192133491712e-10, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.33502087152139154 + ], + [ + 1.996528756755168 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533204425123, + 3.630316688957864 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.5147217416747773e-18, + "std_combined_error": 1.0173963506700801e-20, + "mean_cycle_span": 2.8707525774118444e-08, + "std_cycle_span": 1.008211211346341e-10, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.2839866529869272, + 1.4140559020638932 + ], + [ + 2.0992982944920144, + -0.1862355096516429 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533232749066, + 3.630316745461578 + ], + "bias_strength": 1.0, + "mean_combined_error": 7.627832375710677e-17, + "std_combined_error": 8.907999183187963e-17, + "mean_cycle_span": 9.340505301936189e-08, + "std_cycle_span": 7.0279956013451e-08, + "neutral_observations_during_learning": 240, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.40961218298891705 + ], + [ + 2.213185887579869 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936651647, + 3.630316742081457 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.5792625543975334e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.01398819495276491, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.05, + "cycles": 120, + "half_steps": 125, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.964253393681474, + 3.630316742095593 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.549258815097925e-23, + "std_combined_error": 6.209461805765814e-23, + "mean_cycle_span": 1.0367440195878089e-10, + "std_cycle_span": 1.0965298829349936e-10, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 6.000000000003813, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 3.3882768221995287, + 3.9847125473836953 + ], + "bias_strength": 1.0, + "mean_combined_error": 6.065163347074931e-05, + "std_combined_error": 7.11544194994956e-16, + "mean_cycle_span": 0.2661768713085517, + "std_cycle_span": 1.7761504262354212e-12, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.964751067934781, + 3.621874878697866 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.84718500823959e-08, + "std_combined_error": 1.4277851709520875e-08, + "mean_cycle_span": 0.006844039282168616, + "std_cycle_span": 0.003189052088983512, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9948827337270805, + 3.656967588425128 + ], + "bias_strength": 1.0, + "mean_combined_error": 4.2783429730822625e-07, + "std_combined_error": 1.249236399827717e-18, + "mean_cycle_span": 0.020703809998703283, + "std_cycle_span": 3.397826570547046e-14, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.33502087152139154 + ], + [ + 1.996528756755168 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.964253290923972, + 3.630316677267772 + ], + "bias_strength": 1.0, + "mean_combined_error": 3.2820004315345595e-18, + "std_combined_error": 1.4267738435327517e-25, + "mean_cycle_span": 5.760577929980747e-08, + "std_cycle_span": 1.2105734719707505e-15, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.2839866529869272, + 1.4140559020638932 + ], + [ + 2.0992982944920144, + -0.1862355096516429 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.96425338685285, + 3.630316785982766 + ], + "bias_strength": 1.0, + "mean_combined_error": 4.2695914896844e-17, + "std_combined_error": 4.438713773983293e-17, + "mean_cycle_span": 1.1348019564361219e-07, + "std_cycle_span": 6.109442246241253e-08, + "neutral_observations_during_learning": 240, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.4096124585637328 + ], + [ + 2.213185988465957 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936651647, + 3.630316742081457 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.5792625543975334e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.01398819591109883, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.1, + "cycles": 120, + "half_steps": 250, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936652082, + 3.6303167420815114 + ], + "bias_strength": 1.0, + "mean_combined_error": 9.506390205495396e-31, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 11.99999999999871, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "raw", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 3.8237890439877713, + 4.2322590657718075 + ], + "bias_strength": 1.0, + "mean_combined_error": 0.00020745009918461807, + "std_combined_error": 1.3414351419184588e-16, + "mean_cycle_span": 0.6003387233585882, + "std_cycle_span": 2.345558964216802e-13, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "same_rms_noise", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.964099481543456, + 3.6319122591676485 + ], + "bias_strength": 1.0, + "mean_combined_error": 2.206579663654022e-08, + "std_combined_error": 2.2474838335593827e-08, + "mean_cycle_span": 0.007024101768689795, + "std_cycle_span": 0.00310757766930167, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "frozen_constant", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 3.025804072284264, + 3.6743278033788007 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.5706092974008448e-06, + "std_combined_error": 9.215762501224779e-20, + "mean_cycle_span": 0.04480377417319827, + "std_cycle_span": 1.1877108307227618e-15, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.33502087152139154 + ], + [ + 1.996528756755168 + ] + ] + }, + { + "method": "frozen_sdil", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642532144996294, + 3.630316633618741 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.076305364663816e-17, + "std_combined_error": 0.0, + "mean_cycle_span": 1.1521161904577788e-07, + "std_cycle_span": 2.6469779601696886e-23, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.2839866529869272, + 1.4140559020638932 + ], + [ + 2.0992982944920144, + -0.1862355096516429 + ] + ] + }, + { + "method": "online_constant", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.964253404793115, + 3.6303167944322667 + ], + "bias_strength": 1.0, + "mean_combined_error": 6.331430267398849e-17, + "std_combined_error": 6.545416707926297e-17, + "mean_cycle_span": 2.3644399541514118e-07, + "std_cycle_span": 1.3174095406631684e-07, + "neutral_observations_during_learning": 240, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": [ + [ + -0.4096124578308895 + ], + [ + 2.2131859838848285 + ] + ] + }, + { + "method": "overclamp", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936651647, + 3.630316742081457 + ], + "bias_strength": 1.0, + "mean_combined_error": 1.5792625543975334e-32, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 0.013988195910677756, + "clipped_updates": 0, + "final_predictor_coefficients": null + }, + { + "method": "oracle", + "period_seconds": 0.2, + "cycles": 120, + "half_steps": 500, + "initial_gates": [ + 4.0, + 4.0 + ], + "final_gates": [ + 2.9642533936652082, + 3.6303167420815114 + ], + "bias_strength": 1.0, + "mean_combined_error": 9.506390205495396e-31, + "std_combined_error": 0.0, + "mean_cycle_span": 0.0, + "std_cycle_span": 0.0, + "neutral_observations_during_learning": 0, + "learning_on_time_seconds": 23.999999999970743, + "clipped_updates": 0, + "final_predictor_coefficients": null + } + ], + "summary": { + "sdil_beats_frozen_constant_all_periods": true, + "median_raw_to_oracle_gap_closed_by_sdil": 0.9999999999999502, + "overclamp_beats_sdil_all_periods": true, + "online_constant_neutral_observations_by_period": [ + 6000, + 2400, + 1200, + 600, + 240, + 240, + 240 + ], + "frozen_sdil_neutral_observations_by_period": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + }, + "summary": { + "sdil_beats_frozen_constant_both_pairs": true, + "median_gap_closed_by_pair": { + "experiment_1": 0.9999999864048891, + "experiment_2": 0.9999999999999502 + } + } +} diff --git a/sdil/physical_coupled.py b/sdil/physical_coupled.py index 0216048..f451947 100644 --- a/sdil/physical_coupled.py +++ b/sdil/physical_coupled.py @@ -244,3 +244,158 @@ def local_replay_update( residual = np.asarray(teaching_measurement) - predictor.predict(gates) return learning_rate * residual * np.asarray(eligibility) + +def task_errors(circuit: Circuit, gates: Array, tasks: Iterable[Task]) -> Array: + return np.asarray([ + (task.label_voltage - free_output( + circuit, gates, task.input_voltage)) ** 2 + for task in tasks + ], dtype=float) + + +def simulate_alternating_tasks( + circuit: Circuit, + tasks: Iterable[Task], + bias_field: LocalAffineBias, + *, + method: str, + period_seconds: float, + cycles: int, + initial_gates: Array, + bias_strength: float = 1.0, + predictor: Optional[LocalPredictor] = None, + online_predictor_rate: float = 0.05, + noise_standard_deviation: Optional[Array] = None, + seed: int = 0, + summary_cycles: int = 20, + record_history: bool = False, +) -> dict: + """Alternate two tasks using explicit local circuit updates. + + `online_constant` and `online_sdil` take one neutral observation at the + beginning of each half-cycle. Frozen predictors take none during task + learning. The overclamping implementation uses the leading-order + constant-displacement signal of Eq. F6 and the error-proportional update + duration of Eq. F8; it is an analogue for these regression tasks, not a + reproduction of the paper's classification experiment. + """ + allowed = { + "raw", "frozen_constant", "frozen_sdil", "online_constant", + "online_sdil", "oracle", "same_rms_noise", "overclamp", + } + if method not in allowed: + raise ValueError(f"unrecognized method {method}") + tasks = tuple(tasks) + if len(tasks) != 2: + raise ValueError("exactly two alternating tasks are required") + if period_seconds <= 0.0 or cycles < 1: + raise ValueError("period and cycles must be positive") + if method in { + "frozen_constant", "frozen_sdil", "online_constant", "online_sdil" + } and predictor is None: + raise ValueError(f"{method} requires a predictor") + if method == "same_rms_noise" and noise_standard_deviation is None: + raise ValueError("same_rms_noise requires a standard deviation") + + active_predictor = predictor.copy() if predictor is not None else None + gates = np.asarray(initial_gates, dtype=float).copy() + if gates.shape != (2,): + raise ValueError("initial gates must have shape (2,)") + nominal_step = circuit.integration_step_seconds + half_steps = max(1, int(round(period_seconds / (2.0 * nominal_step)))) + rng = np.random.default_rng(seed) + initial_error_scale = float(np.mean([ + abs(task.label_voltage - free_output( + circuit, gates, task.input_voltage)) + for task in tasks + ])) + initial_error_scale = max(initial_error_scale, 1e-6) + + combined_error_history = [] + cycle_span_history = [] + gate_history = [] + task_error_history = [] + learning_on_time = 0.0 + neutral_observations = 0 + clipped_updates = 0 + + for _ in range(cycles): + half_endpoints = [] + half_task_errors = [] + for task in tasks: + if method in {"online_constant", "online_sdil"}: + neutral = bias_field(gates, bias_strength) + active_predictor.update( + gates, neutral, online_predictor_rate) + neutral_observations += 1 + for _ in range(half_steps): + physical_bias = bias_field(gates, bias_strength) + if method == "overclamp": + clean_rate, output_free, _ = overclamped_clean_rate( + circuit, gates, task) + duration = nominal_step * abs( + task.label_voltage - output_free) / initial_error_scale + residual_bias = physical_bias + else: + clean_rate, _, _ = standard_clean_rate(circuit, gates, task) + duration = nominal_step + if method == "raw": + residual_bias = physical_bias + elif method == "oracle": + residual_bias = np.zeros(2, dtype=float) + elif method == "same_rms_noise": + residual_bias = rng.normal( + loc=0.0, + scale=np.asarray(noise_standard_deviation, dtype=float), + size=2, + ) + else: + residual_bias = ( + physical_bias - active_predictor.predict(gates) + ) + proposed = gates + duration * (clean_rate + residual_bias) + clipped = np.clip( + proposed, circuit.gate_minimum, circuit.gate_maximum) + clipped_updates += int(np.any(clipped != proposed)) + gates = clipped + learning_on_time += duration + half_endpoints.append(gates.copy()) + half_task_errors.append(task_errors(circuit, gates, tasks)) + half_task_errors_array = np.asarray(half_task_errors) + combined_error_history.append(float(np.mean(half_task_errors_array))) + cycle_span_history.append(float(np.linalg.norm( + half_endpoints[1] - half_endpoints[0]))) + gate_history.append(np.asarray(half_endpoints).tolist()) + task_error_history.append(half_task_errors_array.tolist()) + + summary_count = min(summary_cycles, cycles) + combined = np.asarray(combined_error_history[-summary_count:]) + spans = np.asarray(cycle_span_history[-summary_count:]) + result = { + "method": method, + "period_seconds": period_seconds, + "cycles": cycles, + "half_steps": half_steps, + "initial_gates": np.asarray(initial_gates, dtype=float).tolist(), + "final_gates": gates.tolist(), + "bias_strength": bias_strength, + "mean_combined_error": float(np.mean(combined)), + "std_combined_error": float(np.std(combined)), + "mean_cycle_span": float(np.mean(spans)), + "std_cycle_span": float(np.std(spans)), + "neutral_observations_during_learning": neutral_observations, + "learning_on_time_seconds": float(learning_on_time), + "clipped_updates": clipped_updates, + "final_predictor_coefficients": ( + None if active_predictor is None + else active_predictor.coefficients.tolist() + ), + } + if record_history: + result.update({ + "combined_error_history": combined_error_history, + "cycle_span_history": cycle_span_history, + "half_cycle_gate_history": gate_history, + "half_cycle_task_error_history": task_error_history, + }) + return result |
